Python全栈工程师(包、模块 的导入)

简介: ParisGabriel            每天坚持手写  一天一篇  决定坚持几年 为了梦想 为了信仰                         Python人工智能从入门到精通$ pip3 install tensorflow :  第三方模块 tensorf...
ParisGabriel
 
 
 
         每天坚持手写  一天一篇  决定坚持几年 为了梦想 为了信仰
 
   

                      Python人工智能从入门到精通


$ pip3 install tensorflow :
  第三方模块 tensorflow 的安装
  电脑必须有网 命令行自动下载安装
dir(模块名):
  查看模块所有属性

自定义模块导入
示例:

 
 
自定义模块的实现方法

def
myfac(n): print('正在计算', n, '的阶乘') def mysum(n): print("正在计算1+2+3+...+%d的和" % n) name1 = "Audi" name2 = "TESLA" print("mymod模块被加载!")

 

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

  模块  -------->  编译好的Python3文件  --------> Python3解释执行器

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

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

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

示例:

 
 
# 模块的文档字符串:

'''我的自定义模块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__ 列表内的属性  并且只对 from xx import * 有效

示例:

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

__all__ = ['hello1', 'name1']


def hello1():
    pass


def hello2():
    pass


def hello3():
    pass


name1 = 'aaaaaa'
name2 = 'aaaaaa'

 

 

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

示例:

 此模块在用from mymod5 import *导入时,只能导入:
# f1和 name1
def f1():
    pass


def _f2():
    pass


def __f3():
    pass


name1 = 'aaaaa'
_name2 = 'bbbbb'

 

 

随机模块 random
模块名: random
作用:
用于模拟或生成随机输出的模块

 

随机模块 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]) 随机指定序列的顺序(乱序序列)
R.sample(seq,n) 从序列中选择n个随机且不重复的元素

 

系统模块 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模块的函数

函数名 描述
sys.exit([arg]) 退出程序,正常退出时sys.exit(0)
sys.getrecursionlimit() 得到递归嵌套层次限制(栈的深度)
sys.setrecursionlimit(n) 得到和修改递归嵌套层次限制(栈的深度)

 

 

 

包(模块包) package
  包的定义
  包是将模块以文件夹的组织形式进行分组管理的管理方法
  作用:
    一系列模块进行分类管理,有利于防止命名冲突
    可以需要时加载一个或部分模块则不是全部模块
包目录树示例:
  mypack/  (包名)
    __init__.py                      (__init__.py 文件)
    menu.py                         (模块)

    games/                          (子包名1)
      __init__.py             (__init__.py 文件)
      contra.py                (模块)
      supermario.py        (模块)
      tanks.py                  (模块)

    office/                             (子包名2)
      __init__.py              (__init__.py 文件)
      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.path 提供的路径


__init__.py __all__ 列表
  作用:
    用来记录此包中有哪儿些子包或模块在用from import *语句 时被导入
  说明:
    __all__列表只对 from xxx import *语句起作用

包的相对导入:
  包的相对导入是包内模块的相互导入(不能超过包的最高界限

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

 


模块的导入分三种
    import tiem 直接导入模块
    from time import time 导入time模块的time功能
    from mymod import * 导入time模块的所有功能
这里*导入可以直接使用函数不需要加模块名.函数 如果有__all__属性只导入__all__列表里的

包也是分三种 差不多 包所导入的是文件夹

as 给包或者模块、属性、等 改名
(.)统一代表什么什么下的什么什么
解释执行器就是先把.py文件翻译成二进制码.pyc文件再进行运行(先解释后执行)
  但运模块时自动创建__pycache__ 文件夹 里面放.pyc文件 文档字符串和函数一样
  一般用三引号括起来 写就可以了 第一行是标题 换行 第三行开始写详细内容
__name__属性返回一个字符串 如果返回 __main__代表程序主入口 也就是第一个运行的模块
  否则返回当前模块的名字
__all__ 属性是一个列表 当三种导入方式导入时只导入列表里的其他的不导入
__开头的函数 属性 当三种导入方式导入时不导入_开头的隐藏函数 其他的全导入
__init__.py 是必须存在的文件 不存在 此文件夹就不是包
  里面可以写属性 包的文档字符串

导入路径 优先相对路径 其次sys.path路径
  相对路径 就是 当前路径 或 路径名加上模块
  path是系统环境变量列表 相当于全局变量 在任何目录都能调用这个列表里的路径

练习:
1. 猜数字游戏
随机生成一个 0~100之间的一个整数,用变量x绑定
让用户输入一个数y,输出猜数字的结果:
1) 如果y大于x则提示: "您猜大了"
2) 如果y小于x则提示: "您猜小了"
3) 如果y等于生成的数x,则提供示用户"恭喜您猜对了 "并退出猜数字
循环重复上述步聚,直到猜对为止。
猜对了,显示用户猜数字的次数,然后退出程序

答案:

import random
x = random.randrange(101)
i = 0
while True:
    s = int(input("请输入要猜的数字0~100:"))
    i += 1
    if s > x:
        print("大了")
    elif s < x:
        print("小了")
    else:
        print("猜对了")
        print("猜了%d次" % i)
        break

 

这里有个2分算法 100内的猜数字一般不超过7次猜对 10000不超过20次就能猜对

练习:
1. 写一个闹钟程序,启动时设置定时时间,
到时间后打印一句"时间到...." 然后退出程序

import time
def time_out():

    h = int(input("please input:"))
    m = int(input("please input:"))
    s = int(input("please input:"))
    d = (h, m, s)
    while True:
        s = time.localtime()
        print('%02d:%02d:%02d' % (s[3], s[4], s[5]), end = "\r")
        time.gmtime(1)
        if s[3: 6] >= d:
            print("Time out")
            break
time_out()

 

 

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

 答案:

import random
L = {"大王", "小王"}
range(2, 11)
for x in {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"}:
    L.add("\u2660 " + x)
    L.add("\u2663 " + x)
    L.add("\u2665 " + x)
    L.add("\u2666 " + x)
print("共54张牌:", L)
print()
for x in range(3):
    input()
    s = set(random.sample(L, 17))
    if x == 0:
        x = "第一个玩家:"
    elif x == 1:
        x = "第二玩家:"
    elif x == 2:
        x = "第三个玩家:"
    print(x, s)
    L -= s
print()
print("底牌:", L)

 

 

 

 

今天的:
3. 修改学生信息管理程序,将原student_info.py 拆分为模块
要求:
1. 主事件循环放在main.py中
2. show_menu 函数放在menu.py中
3. 与学生操作相关的函数放在 student_info.py中

 

 

 

 

还有昨天的:

3. 改写之前的学生信息管理程序
  要求添加四个功能:
| 5) 按学生成绩高-低显示学生信息 |
| 6) 按学生成绩低-高显示学生信息 |
| 7) 按学生年龄高-低显示学生信息 |
| 8) 按学生年龄低-高显示学生信息 |

 

下载地址:https://pan.baidu.com/s/17xFe_r0g8a-nP1PrUoTXCA

 

已 吐血身亡 下次补上 太晚了  嘤嘤嘤.........

 

# 创建输入函数:input_student开始     封装信息输入

# 创建输出函数:student完成    临时菜单封装


def student():
    for a in range(1, 8, 2):
        x = "*" * a
        print(x.center(9), x.center(10), x.center(10), x.center(9))
    else:
        for y in range(1, 4 + 1):
            c = "*"
            if 4 >= 10:
                c = "***"
            print(c.center(9), c.center(10), c.center(10), c.center(9))
    print("^^^^^^^^^^^^^ System menu ^^^^^^^^^^^^^")
    print("---------------------------------------")
    print("    1):    Add Student information     ")
    print("---------------------------------------")
    print("    2):    print Student information   ")
    print("---------------------------------------")
    print("    3):    delete Student information  ")
    print("---------------------------------------")
    print("    4):    revamp Student information  ")
    print("---------------------------------------")
    print("    5):    Results sorting High --> low")
    print("---------------------------------------")
    print("    6):    Results sorting low --> High")
    print("---------------------------------------")
    print("    7):    Age sort High --> low       ")
    print("---------------------------------------")
    print("    8):    Age sort low --> High       ")
    print("---------------------------------------")
    print("     please input number 1~8 select    ")
    print("---------------------------------------")
    print("        input :(Q)Exit procedure       ")
    print("---------------------------------------")

# 创建输出函数:perform完成


def input_student():
    L = []
    print("--------Student information enty--------")
    while True:
        name = input("please input name:")
        if name == "":
            q = input("operation succeed! return y / n :")
            if q == "y":
                break
            else:
                input_student()
        age = int(input("please input age:"))
        score = int(input("please input score:"))
        d = {}
        d = {"name": name, "age": age, "score": score}
        print("+---------------+----------+----------+")
        name = d["name"].center(15)
        age = str(d["age"]).center(10)
        score = str(d["score"]).center(10)
        print('''|%s|%s|%s|''' % (name, age, score))
        print("+---------------+----------+----------+")
        print("-----Not input Enter be no revamp!-----")
        L.append(d)
    return L
# 创建输入函数:input_student完成

# 创建输出函数:output_student开始   封装列表打印


def output_student(lst):
    print("-------Student information sheet-------")
    print("+---------------+----------+----------+")
    print("|      Name     |    Age   |   Score  |")
    print("+---------------+----------+----------+")
    for x in lst:
        name = x["name"].center(15)
        age = str(x["age"]).center(10)
        score = str(x["score"]).center(10)
        print('''|%s|%s|%s|''' % (name, age, score))
        print("+---------------+----------+----------+")
    q = input("operation succeed! return y / n :")
    if q == "y":
        pass
    else:
        output_student()
# 创建输出函数:output_student完成

# 创建输出函数:delete_student开始  封装删除信息


def delete_student(lst):
    name = input("please input name delete:")
    for x in lst:
        if x["name"] == name:
            print("+---------------+----------+----------+")
            name = x["name"].center(15)
            age = str(x["age"]).center(10)
            score = str(x["score"]).center(10)
            print('''|%s|%s|%s|''' % (name, age, score))
            print("+---------------+----------+----------+")
            delet = input("whether delete (y:yes/y:no):")
            if delet == "y":
                lst.remove(x)
    q = input("operation succeed! return y / n :")
    if q == "y":
        pass
    else:
        delete_student()
# 创建输出函数:delete_student完成

# 创建输出函数:revamp_student()开始   封装更改信息


def revamp_student(lst):
    name = input("please input name revamp:")
    for x in lst:
        if x["name"] == name:
            print("+---------------+----------+----------+")
            name = x["name"].center(15)
            age = str(x["age"]).center(10)
            score = str(x["score"]).center(10)
            print('''|%s|%s|%s|''' % (name, age, score))
            print("+---------------+----------+----------+")
            print("-----not input Enter be no revamp!-----")
            rage = input("please input age revamp:")
            rscore = input("please input score revamp:")
            if rage != "":
                x["age"] = rage
            if rscore != "":
                x["score"] = rscore
            print("+---------------+----------+----------+")
            name = x["name"].center(15)
            age = str(x["age"]).center(10)
            score = str(x["score"]).center(10)
            print('''|%s|%s|%s|''' % (name, age, score))
            print("+---------------+----------+----------+")
            print("-----------revamp perform!------------")
    
    q = input("operation succeed! return y / n :")
    if q == "y":
        pass
    else:
        revamp_student()
# 创建输出函数:revamp_student()完成

# 创建输出函数:output_student_by_score_desc开始 成绩高~低排序


def output_student_by_score_desc(lst):
    def k(d):
        return int(d['score'])
    L = sorted(lst, key=k, reverse=True)
    output_student(L)


# 创建输出函数:output_student_by_score_asc开始 成绩低~高排序

def output_student_by_score_asc(lst):
    L = sorted(lst, key=lambda d: int(d['score']))
    output_student(L)


# 创建输出函数:output_student_by_age_desc开始 年龄高~低排序
def output_student_by_age_desc(lst):
    L = sorted(lst, key=lambda d: int(d['age']),
               reverse=True)
    output_student(L)


# 创建输出函数:output_student_by_age_asc开始 年龄低~高排序
def output_student_by_age_asc(lst):
    L = sorted(lst, key=lambda d: int(d['age']))
    output_student(L)

# 创建输出函数:System_menu()开始    临时封装系统


def System_menu():
    L = []
    while True:
        student()
        select = input("            please input:")
        if select == '1':
            L += input_student()
        elif select == '2':
            output_student(L)
        elif select == '3':
            delete_student(L)
        elif select == '4':
            revamp_student(L)
        elif select == '5':
            output_student_by_score_desc(L)
        elif select == '6':
            output_student_by_score_asc(L)
        elif select == '7':
            output_student_by_age_desc(L)
        elif select == '8':
            output_student_by_age_asc(L)
        elif select == 'q':
            break
# 创建输出函数:System_menu()完成    临时封装系统


# 运行

 

相关文章
|
1天前
|
开发者 Python
确保你的Python环境中已经安装了`python-docx`模块。如果还没有安装,可以通过pip来安装:
确保你的Python环境中已经安装了`python-docx`模块。如果还没有安装,可以通过pip来安装:
8 1
|
1天前
|
安全 网络安全 数据安全/隐私保护
`certifi`是一个Python包,它提供了一个包含Mozilla证书颁发机构(CA)Bundle的PEM文件。
`certifi`是一个Python包,它提供了一个包含Mozilla证书颁发机构(CA)Bundle的PEM文件。
16 7
|
1天前
|
资源调度 计算机视觉 Python
`scipy.ndimage`是SciPy库中的一个子模块,它提供了许多用于处理n维数组(通常是图像)的函数。
`scipy.ndimage`是SciPy库中的一个子模块,它提供了许多用于处理n维数组(通常是图像)的函数。
4 0
|
1天前
|
Python
`scipy.signal`模块是SciPy库中的一个子模块,它提供了信号处理、滤波、频谱分析等功能。这个模块包含了许多用于信号处理的函数和类,其中`butter()`和`filtfilt()`是两个常用的函数。
`scipy.signal`模块是SciPy库中的一个子模块,它提供了信号处理、滤波、频谱分析等功能。这个模块包含了许多用于信号处理的函数和类,其中`butter()`和`filtfilt()`是两个常用的函数。
5 0
|
1天前
|
数据可视化 Python
时间序列分析是一种统计方法,用于分析随时间变化的数据序列。在金融、经济学、气象学等领域,时间序列分析被广泛用于预测未来趋势、检测异常值、理解周期性模式等。在Python中,`statsmodels`模块是一个强大的工具,用于执行各种时间序列分析任务。
时间序列分析是一种统计方法,用于分析随时间变化的数据序列。在金融、经济学、气象学等领域,时间序列分析被广泛用于预测未来趋势、检测异常值、理解周期性模式等。在Python中,`statsmodels`模块是一个强大的工具,用于执行各种时间序列分析任务。
6 0
|
1天前
|
API Python
首先,我们导入了`http.client`模块,它是Python标准库中的一个模块,用于创建和发送HTTP请求。
首先,我们导入了`http.client`模块,它是Python标准库中的一个模块,用于创建和发送HTTP请求。
4 0
|
1天前
|
存储 SQL Python
`urllib.parse`模块是Python标准库`urllib`中的一个子模块,它提供了处理URL(统一资源定位符)的实用功能。这些功能包括解析URL、组合URL、转义URL中的特殊字符等。
`urllib.parse`模块是Python标准库`urllib`中的一个子模块,它提供了处理URL(统一资源定位符)的实用功能。这些功能包括解析URL、组合URL、转义URL中的特殊字符等。
5 0
|
存储 机器学习/深度学习 Python
Python全栈工程师 (exercises)
# 1:给定一个数,判断他是正数,负数,还是0 a = int(input("请输入一该个整数")) if a == 0: print(a, "是0") elif a > 0: print(a, "是正数") else: print(a, "是负数") # 练习2:输入一个季度的数字 输出该季度有那几个月 b = int(input("请输入一个季度:1.
2216 0
|
Python
Python全栈工程师(exercises)
# # 练习: # # 1. 用map函数求: # # 1**3 + 2**3 + 3 ** 3 + .... 9**3 的和 def add_(x): return x ** 3 print(sum(map(add_, range(1, 10)))) # # 2.
1439 0
|
5天前
|
安全 Python
告别低效编程!Python线程与进程并发技术详解,让你的代码飞起来!
【7月更文挑战第9天】Python并发编程提升效率:**理解并发与并行,线程借助`threading`模块处理IO密集型任务,受限于GIL;进程用`multiprocessing`实现并行,绕过GIL限制。示例展示线程和进程创建及同步。选择合适模型,注意线程安全,利用多核,优化性能,实现高效并发编程。
18 3