python笔记13 - 系统模块，自定义模块的编写，模块的搜索路径，PYTHONPATH环境变量，模块的属性：__doc__， __all__，__file__，标准库模块，包
2017-11-02 16:18
731 查看
2017/10/18
系统模块，自定义模块的编写，模块的搜索路径，PYTHONPATH环境变量，模块的属性：__doc__， __all__，__file__，标准库模块，包
1.系统模块 sys与系统相关的信息
显示数据：
sys.path 模块搜索路径,path[0]是当前脚本信息的路径名，或者是''
sys.modules 已加载模块的字典
sys.version 版本信息
sys.version_info 版本信息的命名元组
sys.argv 命令行参数，argv[0]代表当前脚本程序路径名@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@是个列表
sys.copyright 获取python版权相关信息
sys.builin_module_names 获得python内置（建）模块名称（字符串元组）（存放字符串的元组）
实例：
交互模式下
>>>
import sys （sys是一个程序文件的文件名，但是没有后缀名）
sys.path
['','/usr/lib/python35.zip', '/usr/lib/python3.5','/usr/lib/python3.5/plat-x86_64-linux-gnu', '/usr/lib/python3.5/lib-dynload',
'/home/tarena/.local/lib/python3.5/site-packages','/usr/local/lib/python3.5/dist-packages', '/usr/lib/python3/dist-packages']
交互模式下第一个路径默认是空，如果是其他环境，将显示python3的路径
实例：
sys.modules
{'posixpath':<module 'posixpath' from '/usr/lib/python3.5/posixpath.py'>,'encodings.aliases': <module 'encodings.aliases' from'/usr/lib/python3.5/encodings/aliases.py'>,
'rlcompleter': <module 'rlcompleter' from'/usr/lib/python3.5/rlcompleter.py'>,
是一个字典，显示当前程序使用了那些模块
实例：
>>>sys.version
'3.5.2 (default,Nov 17 2016, 17:05:23) \n[GCC 5.4.0 20160609]'
显示解释执行器的版本信息
实例：
>>>sys.version_info
sys.version_info(major=3,minor=5, micro=2, releaselevel='final', serial=0)
版本信息命名元组，可以取得数据：
sys.version_info[1]
sys.version_info.minor
实例：
sys.copyright
print(sys.copyright)
'Copyright (c)2001-2016 Python Software Foundation.\nAll Rights Reserved.\n\nCopyright (c)2000 BeOpen.com.\nAll Rights Reserved.\n\nCopyright (c) 1995-2001 Corporationfor National Research Initiatives.\nAll Rights Reserved.\n\nCopyright (c)1991-1995 Stichting
Mathematisch Centrum, Amsterdam.\nAll Rights Reserved.'
>>>print(sys.copyright)
Copyright (c)2001-2016 Python Software Foundation.
All RightsReserved.
----------------------------------------------------
命令行参数：
python3abc.py 命令行
----------------------------------------------------
实例sys.argv (sys.argv返回显示的是一个字符串序列)：
import sys
print("参数的个数是：",len(sys.argv)，这里的执行参数是指运行的程序)
print(sys.argv)
如果：
>>>python3yuan.py
参数的个数是： 1
['yuan.py']
如果：
>>>python3yuan.py a.py b.py
参数的个数是： 3
['yuan.py','a.py', 'b.py']
---------------------
#!/usr/bin/python3
import sys
print("参数的个数是：",len(sys.argv))
print(sys.argv)
for x insys.argv:
print('参数是：',x)
键入：python3 yuan.pya.py b.py #或者./yuan.pya.py b.py
参数的个数是： 3
['yuan.py','a.py', 'b.py']
参数是： yuan.py
参数是： a.py
参数是： b.py
----------------------------------------------------
练习实例：
写一个程序 myadd.py,然后执行此程序
如果执行以下命令：
$ ./myadd.py 用法：$./myadd.py 数字 运算符 数字
$./myadd.py 5 加 2
结果是：7
$./myadd.py 5 乘 2
结果是：10
解：
#!/usr/bin/python3
import sys
while 1:
if sys.argv[2] == '加':
print('结果是：%d' %(int(sys.argv[1]) + int(sys.argv[3])))
break
if sys.argv[2] == '乘':
print('结果是：%d' %(int(sys.argv[1]) * int(sys.argv[3])))
break
曾出现bug：
键入值：$./myadd.py 5 乘 2 中空格应为英文状态下的空格；
if sys.argv[2] =='加': 中的冒号应为英文状态下的冒号
----------------------------------------------------
#!/usr/bin/python3 #@@@@@@@@@@@@@@@@@@@@@@@@@@@@
import sys
iflen(sys.argv)<4:
print("用法：./myadd.py 数字 运算符 数字")
sys.exit(0) #退出程序 #@@@@@@@@@@@@@@@@@@
if sys.argv[2] =='加':
print(float(sys.argv[1])+float(sys.argv[3]))
elif sys.argv[2]== '乘':
print(float(sys.argv[1])*float(sys.argv[3]))
>>>键入
python3 madd.py 2加 3
./madd 2 加 3 均会返回打印对应的值
>>>键入
python3 madd.py 2
print("用法：./myadd.py数字 运算符 数字")
退出程序
总结：
import sys
sys.argv
可以像输入语句 input 一样读取终端键入的数据，相似的是，两个函数读取的都是字符形式的数据，不同的是
input是执行了函数以后再从终端键入数据供程序使用，执行命令语句该输入还是得输入而sys.argv是在键入执
行语句命令时，就已经开始读取输入字符数据了
=======================================================================================
2.函数（需要importsys）
sys.exit([code]) 退出程序，正常退出时sys.exit(0) #这个值可以设置为123等错误值，是shell脚本中的值，相似exit()函数@@@@@@@@@
sys.getrecursionlimit() 得到递归的层次限制值
sys.setrecursionlinit(n) 设置递归的最大层次限制值
实例：
>>>import sys
>>>sys.getrecursionlimit()
1000
=======================================================================================
3.自定义模块的编写
例：
#file: 建立文件并命名为mycod.py，在此文件下写入以下函数
def fac(n):
print('正在计算n的阶乘...')
def sum_fac(n):
print('正在计算阶乘的和...')
----------------------------------------------------
交互环境（或者同一路径下，写文档函数进行测试）测试：
>>>import mymod
>>>dir(mymod)
['__builtins__','__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__','fac', 'sum_fac']
>>>mymod.fac(100)
正在计算n的阶乘...
----------------------------------------------------
文档测试(同一路径)：
#mymod_test.py:
from mymod import*
fac(100)
sum_fac(200)
执行 python3mymod_test.py
>>>
正在计算n的阶乘...
正在计算阶乘的和...
=======================================================================================
4.模块的搜索路径
import 模块名 #对应 模块名.py 去哪儿找
查找的顺序：
(1)搜索内置模块：sys.builtin_modules_names
(2)sys.path提供的路径
(3)搜索程序运行时的路径（）
例：(如果一个程序想要调用一个非本目录下的写好的模块)
import sys
sys.path.append('/home/aid1709/tarena')
from mymod import*
fac(100)
sum_fac(200)
练习：
将昨天写的练习的函数成一个模块day.py,在写一个主模块来调用相应的函数@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
文件yuan.py 位置/home/tarena/aid1709 调用模块
文件dayclock.py 位置/home/tarena/aid1709/1 被调用模块
解：
import sys #导入系统模块
sys.path.append('/home/tarena/aid1709/1') #导入系统模块，并将需要调用的模块添加到系统模块路径
from dayclockimport * #这样就可以像导入系统模块一样调用dayclock模块（文件名，没有.py后缀名）
hanshu() #可以调用dayclock模块中定义的函数了
=======================================================================================
5.PYTHONPATH环境变量
此环境变量的值会在python3的解析器启动时自动加载到sys.path列表中
Linux/Unix下用命令 printenv查看所有的环境变量
$ printenv 可以查找环境变量
----------------------------------------------------
(1)
针对 ./shiyan.py
修改环境变量：
$export PATH =$PATH:/ home/tarena 将执行文件的路径添加到环境变量中，以后不必写./shiyan.py 而直接键入shiyan.py即可运行(任何路径下均可)
$echo $PATH 查看系统执行路径，找环境变量，找命令（如果在同一路径，查看时会在后路径后面自动追加其位置路径）
说明：修改变量只在当前的设置终端有用
----------------------------------------------------
(2)
针对 python3 shiyan.py
修改环境变量：
$ exportPYTHONPATH = $PATHONPATH:/home/tarena 将执行文件的路径添加到环境变量中，以后不必写ython3 shiyan.py 而直接键入shiyan.py即可运行(任何路径下均可)
$echo $PATH 查看系统执行路径，找环境变量，找命令（如果在同一路径，查看时会在后路径后面自动追加其位置路径）
说明：修改变量只在当前的设置终端有用
----------------------------------------------------
windos下的环境变量的设置
计算机 属性 高级设置 系统属性 环境变量
=======================================================================================
6.模块的加载过程：
(1)在模块导入时，模块内的所有语句会执行；
(2)如果一个模块已经导入，如果重新导入，则不会执行重复的语句
=======================================================================================
7.模块化编程的优点(实质是准备多个文件形成模块库，文件内定义了多个备用函数，在主程序文件中导入即调用模块就可以使用，导入模块的写法就是 import 文件名（文件名不需要添加.py的后缀名）)
(1)有利于多人开发；
(2)使代码更加易于维护；
(3)提高代码的复用率；
(4)模块化编程有助于解决函数名和变量名冲突的问题
=======================================================================================
8.模块的属性：
__name__属性：记录模块自身的名字
(1)对于被导入模块，模块名为去掉路径前缀和“.py”后缀文件名
/home/tarena/aid1709/1/nihao.py 中的 nihao
(2)对于被执行的主模块，模块名为'__main__'(__name__：返回本函数的属性名)
作用：
(1)记录模块名
(2)用来判断是否为主模块
主模块：该文件中定义了函数，自己使用，没有调用其他文件中的函数
方法：print(__name__)
常用测试方法：
if __name__ ==__main__ #@@@@@@@@@@@@@
----------------------------------------------------
9.__doc__属性:
用来绑定模块的文档字符串
模块的文档字符串是模块中第一行出现的没给赋值
实例：
模块：mymod4
内容如下：
########################################
'''
模块文档字符串
'''
def f1()：
'''
函数f1()文档字符串 ###### 注意，定义函数中文档字符串也需要进行缩进处理，否则导入时会报缩进出错
'''
print('f1 被调用')
def f2()：
print('f2 被调用')
########################################
交互环境：
>>>importmymod4
>>>help(mymod4)
打印：
NAME
yuan - 模块文档字符串
FUNCTIONS
f1()
模块文档字符串
或者键入：
mymod4.__doc__
mymod4.f1.__doc__
--------------------------------------------------------------------
10.__all__属性
作用：
当用from import * 语句导入模块时，只导入__all__列表内的变量（属性）；
__all__属性是用来寻访可导出属性的列表
实例：
被导入模块 yuan
内容如下：
########################################
__all__ =["hello1","hello2","name1"]
def hello1():pass
def hello2():pass
def hello3():pass
def hello4():pass
name1 = 'aa'
name2 = 'bb'
########################################
导入模块：
交互环境中：
>>>fromyuan import *
>>>dir()
['__builtins__', '__doc__','__loader__', '__name__', '__package__', '__spec__', 'hello1', 'hello2','name1']
显示 yuan 模块中只有函数对象'hello1', 'hello2', 'name1' 被导入了
注：dir():看导入变量
--------------------------------------------------------------------
11.__file__属性
作用：
用来记录模块对应的文件路径名
对于导入的模块，交互环境中键入:
>>>yuan.__file__
'/home/tarena/aid1709/yuan.py'
--------------------------------------------------------------------
12.模块的隐藏属性
模块中以 '_' 或 '__'开头，不以'__'结尾的属性，在用 fromxxx import * 语句导入时，将不被导入到其他模块
模块名：yuan
内容如下：
########################################
def _abc():
pass
def __abc():
pass
def abc():
pass
name1 ="hello1"
_name2 ="hello2"
__name3 ="hello3"
########################################
交互环境中：
>>> fromyuan import * #模块隐藏属性只针对from import * 语句
>>>abc() #函数导入成功
>>>_abc() #函数导入失败
Traceback (mostrecent call last):
File "<stdin>", line 1, in<module>
NameError: name'_abc' is not defined
>>>name1 #变量导入成功
'hello1'
>>>_name1 #变量导入失败
Traceback (mostrecent call last):
File "<stdin>", line 1, in<module>
NameError: name'_name1' is not defined
=======================================================================================
12.标准库模块
随机模块 random
假设导入：
import random as R
函数：
R.random() 返回一个(0,1]之间的随机数
R.getrandbits(nbit) 以长整型的形式返回用nbit位来表示的随机数
R.uniform(a,b) 返回区间内的随机数
R.randrange([start,]stop [,step]) 返回range(start,stop,step中的随机数)
R.choice(seq) 从序列中返回随意元素
R.shuffle(seq) 随机指定序列的顺序（乱序序列）
R.sample(seq,n) 从序列中选择n个随机且不重复的元素
实例：
import random asR
print(R.random()) #返回一个[0,1)之间的随机数,如果社鞥成更高的数，需要乘以100,1000，然后int取整，或天花板，地板取整
R.getrandbits(8) #返回[0,255]之间的随机整数
R.uniform(5，10) #(5，10)
R.randrange(1,10,2) #从range(1,10,2) ，即从1，3，5，7，9 中随机取一个数
L = [1，23，54，6，7，8，0]
R.choice(L) #从列表序列中任意返回一个值
R.shuffle(L) #打乱L列表的元素顺序,不返回序列值，只是对列表元素进行打乱操作。
因此需要先执行此语句，然后print(L)才显示列表的新列表@@@@@@@@@@@@@
R.sample(L,2) #从序列L中选择2个随机且不重复的元素，并形成列表返回#@@@@@@@@@@@@@@@@@@@@@
练习：
猜数字：随机生成一个0~100之间的一个整数，保留在变量x中，让用户输入一个数y，输出猜数字的结果:
如果y等于x，提示"恭喜你猜对了"，并退出程序；
如果y大于x，提示"您猜的数大了"，并让用户继续猜数；
如果y小于x，提示"您猜的数小了"，并让用户继续猜数；
直到猜对为止退出程序，并显示用户猜数字的次数
解：
from randomimport *
x =int(uniform(0,100))
i = 0
while 1:
y = int(input('请猜一个数:'))
if y > x:
print('您猜的数大了！')
i = i + 1
if y < x:
print('您猜的数小了！')
i = i + 1
if y == x:
print('恭喜您！猜对了！')
i = i + 1
break
print('您一共猜了%d次' % i)
=======================================================================================
13.包(模块包) package
包的定义:
包是将模块以文件夹的组织形式进行分组管理的方法
包是作用：
(1)将一系列模块进行分类管理，有利于防止名字冲突；
(2)可以在需要时加载一个或部分模块而不是全部模块
实例：
mypack/ #包
__init__.py #必须存在的文件，导入包的时候自动执行，即初始化
menu.py
games/
__init__.py
contra.py
supermario.py
tanks.py
office/
__init__.py
execl.py
word.py
powerpoint.py
包的加载：
import 包名 [as 包别名]
import 包名.模块名 [as 模块别名]
import 包名.子包名.模块名 [as 模块别名]
...
包名：文件夹的名称
importmypack #导入包
importmypack.menu #导入模块
importmypack.menu.show_menu() #导入包中的模块中的定义的函数，这样才能执行导入的函数
from 包名 import 模块名 [as 模块新名]
from 包名.子包名 import 模块名 [as 模块别名]
from 包名.模块名 import 变量名 [as 变量别名]
...
from 包名 import *
from 包名.模块名 import
…
========================================
案例操作：
pack/
__init__.py
menu.py
games/
__init__.py
contra.py
supermario.py
tanks.py
----------------
pack.__init__py模块内容:
'''
pack 已经被加载
'''
print('pack-__init__.pybei jia zai ')
----------------
pack.menu模块内容:
def showmenu():
print('1.contra')
print('2.supermario')
print('3.tanks')
print('pack-menu.pyyij ing bei jia zai')
----------------
pack.games.__init__py模块内容:
print('pack-games-__init__.pyyi jing bei jia zai')
----------------
pack.games.contra模块内容：
def play():
print('zheng zai wan contra')
print('pack-games-contrayi jing bei jia zai')
----------------
pack.games.supermario模块内容：
def play():
print('zheng zai wan supermario')
print('pack-games-supermarioyi jing bei jia zai')
----------------
pack.games.tanks模块内容：
def play():
print('zheng zai wan tanks')
print('pack-games-tanksyi jing bei jia zai')
----------------
在于pack包同路径的终端下键入python3进入交互环境：
>>>import pack
bao pack bei jiazai
>>>import pack.menu
pack-menu.py yijing bei jia zai
>>>pack.menu
<module'pack.menu' from '/home/tarena/pack/menu.py'>
>>>pack.menu.showmenu()
1.contra
2.supermario
3.tanks
>>>import pack.games.contra
pack-games-__init__.pyyi jing bei jia zai
pack-games-contrayi jing bei jia zai
>>>import pack.games.supermario
pack-games-supermarioyi jing bei jia zai
>>>import pack.games.contra
pack-__init__.pybei jia zai
pack-games-__init__.pyyi jing bei jia zai
pack-games-contrayi jing bei jia zai
>>>pack.games.contra.play()
zheng zai wancontra
>>> frompack.games import contra
pack-__init__.pybei jia zai
pack-games-__init__.pyyi jing bei jia zai
pack-games-contrayi jing bei jia zai
>>>contra.play
<function playat 0x7ff6fe07b9d8>
>>>contra.play()
zheng zai wancontra
----------------
>>>import pack
pack-__init__.pybei jia zai
>>>help(pack)
Help on packagepack:
NAME
pack - pack 已经被加载 #显示的是包 - __init__模块中的文档字符串
PACKAGE CONTENTS
games (package) #内部有__init__模块，所以被认为是包
menu
office (package)
FILE
/home/tarena/pack/__init__.py
========================================
--------------------------------------------------------------------
包内的__init__.py文件：
作用：
(1)在包被加载时自动调用
(2)在内部填写包的文档字符串
(3)加载此包所依赖的一些模块或其他包
实例：
'''
演示包的使用
'''
print('加载了')
help(包名) 显示__init__.py内的文档字符串
--------------------------------------------------------------------
__init__.py内的__all__属性：
作用:
(1)记录哪些包需要被导入
(2)当用 from 包 import * 语句导入模块时，只查找__all__中所列出的模块
__all__属性只在fromimpport *语句中起作用
在文件__init__.py文件的开头写入：__all__= ['games','menu']
当用 from 包 import * 语句导入模块时，会导入相应的依赖的包games，menu
模块里的__all__可以加载函数；
包中的__all__可以加载一些依赖的包
--------------------------------------------------------------------
包的加载路径：
同模块相同，设置方法：
1.可以设置sys.path
2.可以设置PYTHONPATH环境变量
--------------------------------------------------------------------
模块的加载过程：
menu.py -->menu.pyc --> python3
编译 解释执行
=======================================================================================
课后练习：
1.
模拟斗地主发牌，扑克共54张，黑桃（'\u2660'），梅花（'\u2663'）,方块（'\u2665'）,桃('\u1666')
A2-10JQK
大小王
三个人，每个人发17张牌，底牌留三张：
输入回车，打印第1个人的17张牌
输入回车，打印第2个人的17张牌
输入回车，打印第3个人的17张牌
输入回车，打印3张底片牌
R.choice(seq) 从序列中返回随意元素
R.shuffle(seq) 随机指定序列的顺序（乱序序列）
R.sample(seq,n) 从序列中选择n个随机且不重复的元素
--------------------------------------------
我的解法：
from randomimport *
l1 =['\u2660','\u2663','\u2665','\u2666']
l2 =['A','2','3','4','5','6','7','8','9','10','J','Q','K']
lc = []
for x in l1:
for y in l2:
lc.append('%4s' % (x+' '+y))
l3 =['BRO1','BRO2']
lc.extend(l3)
sc = set(lc)
L1 =sample(sc,17)
s1s = sc -set(L1)
print('第1个人的牌：\n',L1)
L2 =sample(s1s,17)
s2s = s1s -set(L2)
print('第2个人的牌：\n',L2)
L3 =sample(s2s,17)
s3s = s1s -set(L3)
print('第3个人的牌：\n',L3)
L4 =sample(s3s,3)
print('底牌：\n',L4)
--------------------------------------------
助教的解法：
import random
kinds = ['A'] +[str(x) for x in range(2,11)] + ['J','Q','K']
color =['\u2660','\u2666','\u2663','\u2665']
king =['big','small']
def all_cards():
all_c = []
for x in color:
for y in kinds:
all_c.append(chr(ord(x)) + ' ' + y)
all_c += king
return all_c
def get_cards():
new_c = all_cards()
random.shuffle(new_c)
return(new_c[0:17],new_c[17:34],new_c[34:51],new_c[51:])
def test():
first,second,third,last = get_cards()
input('按回车继续')
print('第1个人的17张牌：',first)
input('按回车继续')
print('第2个人的17张牌：',second)
input('按回车继续')
print('第3个人的17张牌：',third)
input('按回车继续:')
print('底牌：',last)
if __name__ == "__main__":
test()
--------------------------------------------
曾出现的bug：
1.定义函数cards()时少添加一个s；
2.末尾进行模块是否为主模块判断时，应将"name"写为"__name__"
重要知识：
(1).通过列表推导式、range函数生成数字字符串序列
kinds = ['A'] + [str(x) for x in range(2,11)]+ ['J','Q','K']
(2). \uXXXX Unicode 16的十六进制字符（XX第一个字节，XX第二个字节），输入编码，输出符号
color = ['\u2660','\u2666','\u2663','\u2665']
(3).for循环嵌套实现两个字符串列表的的交叉组合；列表元素的追加；
ord（s）：返回一个字符的编码值（ascii/unicode值）；chr（i）：返回i这个编码值所对应的字符；
for x in color:
for y in kinds:
all_c.append(chr(ord(x)) + ' ' + y)
(4).列表可以相加
all_c += king
(5).返回多值，序列赋值
def get_cards():
return(new_c[0:17],new_c[17:34],new_c[34:51],new_c[51:])
first,second,third,last= get_cards()
(6).一个回车，一个操作（打印语句）
input('按回车继续')
print('第1个人的17张牌：',first)
=======================================================================================
2.
已知有5位朋友，第5位比第4位大两岁，第4位比第3位大两岁，第3位比第2位大两岁，第2位比第1位大两岁，
第1位朋友说他10岁，试写出程序算出第5位朋友几岁。
递归完成
-------------------------------------
我自己的解法：
from randomimport *
a1 = 10
def f(x):
return (x - a1 == 8)
f()
while 1:
a5 = int(uniform(0,100))
if f(a5):
break
print('第５位朋友的年龄：%d'% a5)
-------------------------------------
助教的解法：
def age(n):
if n == 1:
return 10
return age(n-1) + 2 # 10 + 2 + 2 + 2 + 2
print(age(5))
=======================================================================================
3.
猜数字，0-9十个数字，分别放在四个盒子内(列表中放四个元素，不能重复)，[4,6,0,3]
用户每次输入4个数字
4603<回车> 输出 4A0B 全对，程序结束
4601<回车> 输出 3A0B (A代表位置对，数字也对， B代表数字对，位置不对)
1046<回车> 输出 0A3B
我的解法：
from randomimport *
L1 = []
for i inrange(0,10):
L1.append(i)
LN = sample(L1,4)
while 1:
a = input('请输入4个数：')
LU = list(a)
l=[]
for i in range(4):
l.append(int (LU[i]))
def fa():
jishua = 0
for i in range(4):
if l[i] == LN[i]:
jishua = jishua + 1
la = [jishua,'A']
return la
def fb():
jishub = 0
for i in range(4):
if l[i] != LN[i]:
if l[i] in LN:
jishub = jishub + 1
lb = [jishub,'B']
return lb
def fc():
aa = fa()
bb = fb()
cc = str(aa[0])+aa[1]+str(bb[0])+bb[1]
return cc
if fc() != '4A0B':
print(fc())
print(LN)
else:
print("恭喜您猜对了！")
break
-------------------------------------
助教的解法:
优势：
(1)短
(2)进行判断的是对应的4位数字，由于输入的是字符串，先将字符添加成为列表，在用列表取值进行比较（比较时再转化为整型数据），
(3)if __name__ == "__main__":
guess_num()
出现bug：
1. if int(L1(i)) == rnd_num[i]: 应该写成 if int(L1[i]) == rnd_num[i]:
-------------------------------------
import random
L =list(range(10))
rnd_num =random.sample(L,4)
print(rnd_num)
def guess_num():
while True:
cor = 0
err = 0
pn = input('请输入四个数字：')
L1 = list(pn)
for i in range(4):
if int(L1[i]) == rnd_num[i]:
cor += 1
elif int(L1[i]) in rnd_num:
err += 1
if cor == 4:
print('输入全对，程序结束！')
break
print('%dA%dB' % (cor,err))
if __name__ == "__main__":
guess_num()
if __name__ == "__main__":
test()
每一个模块都有自己的__name__属性，如果某个文件被import,则该模块__name__为这个模块的名字；
如果这个模块直接运行，则其__name__为’__main__’;
如果没有if这一句话，模块被import的时候，这个模块中的这些代码会被执行一次，这个结果是不需要的；
可以为模块的测试写一个专门的test()函数，将test()放在if语句中，便于测试；
这样只有在模块被执行时才会执行if语句，被import时，不会产生干扰
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 详解Linux系统修改环境变量PATH路径的方法
- Python Import机制备忘-模块搜索路径(sys.path)、嵌套Import、package Import
- Python Import机制备忘-模块搜索路径(sys.path)、嵌套Import、package Import(转)
- 详解Linux系统修改环境变量PATH路径的方法
- Python Import机制备忘-模块搜索路径(sys.path)、嵌套Import、package Import
- 给PATH环境变量增加自己的命令搜索路径
- 详解Linux系统下修改环境变量PATH路径的方法
- Python学习笔记-模块介绍（三）-模块包和搜索路径
- Python Import机制备忘-模块搜索路径(sys.path)、嵌套Import、package Import
- 【杂谈】Linux系统修改环境变量PATH路径---终结篇
- Path环境变量包含不存在的路径时对dll搜索的影响
- Linux系统修改环境变量PATH路径---终结篇 vi /etc/environment
- “LIB 环境变量”中指定的搜索路径“D:\Program Files\Microsoft Visual Studio\VC98\lib”无效 --“系统找不到指定的路径
- python模块搜索路径 （sys.path）
- “LIB 环境变量”中指定的搜索路径"%LIB%"无效 --“系统找不到指定的路径。”
- python学习二：路径搜索、模块加载、变量命名初探
- linux下安装 python， 将其加到 系统环境变量PATH中
- Python Import机制备忘-模块搜索路径(sys.path)、嵌套Import、package Import
- Python Import机制备忘-模块搜索路径(sys.path)、嵌套Import、package Import
- Python Import机制备忘-模块搜索路径(sys.path)、嵌套Import、package Import