python基础day13笔记

2018.7.18

day12回顾

模块

模块的分类：

1.   内置模块
2.   标准库模块
3.   第三方模块（如:$pip3 install tensorflow）
4.   用户自己编写的模块

模块导入语句有三种：

import 语句

例：

1.   import math
2.   math.factorial(5)
3.   import math as m
4.   m.factorial(5)

 from import 语句

 例：

1.   from math import factorial
2.   factorial(5) 
3.   from math import factorial as f
4.   f(5) 

 from import * 语句

  例：

1.   from math import *
2.   sin(pi/2）

 dir() 函数 返回当前作用域内有哪儿些变量
         ..

day13

自定义模块并导入

  示例：

1. mymod.py # 被导入模块
2. # 此文件用来示意自定义模块的定义和导入
3. def fac(n):
4.     print("正在计算", n, "的阶乘...")
5. def sum_fac(n):
6.     print("正在计算", n, "的阶乘的和!!") 
7. name1 = 'audi'
8. name2 = 'tesla'
9. print("mymod 模块被加载!")

 

1. test.py # 主模块
2. # 此示例来示意调用mymod.py中的函数和变量
3. import mymod  # 导入自定义的mymod模块
4. print("---------------------")
5. mymod.fac(10)
6. mymod.sum_fac(30)
7. print("mymod.name1 =", mymod.name1)
8. name1 = 'home'

注意事项：

  自定义模块的文件要求以.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

模块的文档字符串：

  模块内第一个没有复制给任何变量的字符中称为模块的文档字符串

模块的. __doc__ 属性

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

模块的. __file__ 属性

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

示例：

# mymod.py
# 自示例示意模块的文档字符串
'''我的自定义模块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__列表内的属性

示例：

# 此示例示意模块内的 __all__列表的用法

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

__all__ = ['hello1', 'name1']


def hello1():
    pass


def hello2():
    pass


def hello3():
    pass


name1 = 'aaaaaa'
name2 = 'aaaaaa'

 

模块的隐藏属性

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

示例：

def f1():
    pass


def _f2():
    pass


def __f3():
    pass


name1 = 'aaaaa'
_name2 = 'bbbbb'

随机模块：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])	随机指定序列的顺序(乱序序列），例：c=[1,2,3,4,5] , R.shuffle(c)  ,c=[4, 2, 1, 3, 5],注：顺序是随机的
R.sample(seq,n)	从序列中选择n个随机且不重复的元素

练习：

 1，猜数字游戏

随机生成一个0-100之间的整数，用变量v绑定，让用户输入一个数y，输出猜数字的结果：

1）如果y大于x则表示：你猜大了

2）如果y小于x则表示：你猜小了

3）如果y等于生成的数x，则提示用户‘恭喜你猜对了’，并退出猜数字

循坏重复上述步骤，直到猜对为止。

猜对了，显示用户猜数字的次数，然后退出程序

import random
x=random.uniform(0,101)//1  #x=random.randrange(0,101)
i=0
while True:
    y=int(input('输入数字: '))
    if y > x:
        print('你猜大了')
    elif y < x:
        print('你猜小了')
    else:
        print('恭喜你猜对了')
        break
    i+=1
print('次数:',i)

包（模块包）package

包的定义

 包是将模块以文件夹的组织形成进行分组管理的管理方法

作用：

 将一系列模块进行分类管理，有利于防止命名冲突

 可以在需要时加载一个或部分模块则不是全部模块

包示例：

• mypack/
•     __init__.py
•     menu.py
•     games/
•          __init__.py
•         contra.py
•         supermario.py
•         tanks.py
•     office/
•         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.payh 提供的路径.

__init__.py内的__all__列表

作用：

  用来记录此包中有哪儿些子包或模块再用from import * 语句时被导入

说明：

  __all__列表只对from xxx import * 语句起作用

示例：

1. # mypack/games/__init__.py
2. # 此列表的作用是在from mypack.games import *时只导入:
3. # contra 和 tanks 模块
4. __all__ = ['contra', 'tanks']
5. print("games子包被加载")

 

包的相对导入：

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

语法：

  from 相对路径包或模块 import 属性或模块名

  from 相对路径包或模块 import *

相对路径：

• .代表当前目录
• ..代表上一级目录
• ...代表上二级目录
• ....以此类推

注：相对导入时不能超出包的外部

 

练习：

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

答案：

import time


def alarm(h, m):
    while True:
        cur_time = time.localtime()  # 得到本地时间
        print("%02d:%02d:%02d" % cur_time[3:6],
              end='\r')
        time.sleep(1)
        # if h == cur_time[3] and m == cur_time[4]:
        if (h, m) == cur_time[3:5]:
            print("\n时间到....")
            return


if __name__ == '__main__':
    hour = int(input("请输入定时的小时: "))
    minute = int(input("请输入定时的分钟: "))
    alarm(hour, minute)

 

2，模拟斗地主发牌，扑克牌共54张，黑桃（'\u2600）,梅花('\2663'),方块('\2665'),红桃('\u2666')

A2-10JQJ

大王，小王

三个人玩，每个人发17张牌，底牌留13张

输入回车，打印出第1个人的17张牌

输入回车，打印出第2个人的17张牌

输入回车，打印出第3个人的17张牌

输入回车，打印三张底牌

答案：

import random


kinds = ['\u2660 ', '\u2663 ', '\u2665 ', '\u2666 ']
numbers = ['A'] + [str(i) for i in range(2, 11)
                   ] + list("JQK")

pokes = ['大王', '小王']  # 用于存储扑克信息的列表
for k in kinds:
    for n in numbers:
        pokes.append(k + n)

# 洗牌:
random.shuffle(pokes)
# 发牌
input()
print("第1个人的17张牌是:", pokes[:17])
input()
print("第2个人的17张牌是:", pokes[17:34])
input()
print("第3个人的17张牌是:", pokes[34:51])
input()
print("底牌是:", pokes[51:])

 

3，修改学生信息管理程序，将原student_info.py 拆分为模块

要求：

  1，主事件循环放在main.py中

  2，show_menu 函数放在menu.py中

  3，与学生操作相关的函数放在student_info.py中