导入模块
[了解]导入模块的方式
==目标:==了解导入模块的方式有哪些?
模块指的是:以.py结尾的Python文件。
注意:模块名属于标识符。
在模块中,能定义函数、变量和类等,也能包含其他一些可执行的代码,比如print(xxx)、import xx等。
使用模块前,要先导入模块。
导入模块有3种方式:
import 模块名1[, 模块名2...]from 模块名 import 功能1[, 功能2, 功能3...]from 模块名 import *
==总结:==
(1)在使用模块前,需要先导入模块;
(2)常用的导入模块的方式有:import xx、from xx import xx。
[掌握]import xxx
==目标:==掌握import导入模块的使用。
import关键字导入模块语法:
import 模块名1 import 模块名2 ......
此外,也可以使用:
import 模块名1[, 模块名2, ...] # 不推荐
调用模块中的函数语法:
模块名.函数名([值1, 值2, ...])
为便于操作导入模块。来看看math模块的函数:
函数名 | 含义 |
---|---|
pow(x, y) | 返回x^y^(x的y次方)的值。 |
sqrt(x) | 返回数值x的平方根。 |
例如,一起来完成:
(1)使用import导入math模块;
(2)求解2^10^ = 1024的值;
(3)求解9的平方根为多少?
# 1.导入模块
import math # 升级: 声明、定义
# 2.求解次方
print(math.pow(2,10))
# 3.求解平方根
print(math.sqrt(9))
# def func():
# import random
# print(random.randint(0,10))
# pass
==总结:==
(1)请问:建议使用import直接导入模块时,放在py文件的顶部,这句话正确吗?==A、正确==;B、不正确;
(2)建议使用import导入模块时,一行导入一个模块。
[掌握]from xx import xx
==目标:==掌握from xx import xx的使用。
from xx import xx导入模块功能语法:
from 模块名 import 功能1[, 功能2, 功能3...]
此外,也可以使用:
from 模块名 import 功能1 # 不推荐 from 模块名 import 功能2 ......
调用模块中的功能语法:
功能1() 功能2()
为便于操作导入模块。来看看math模块的函数:
函数名 | 含义 |
---|---|
ceil(x) | 返回数值x的上入整数,如math.ceil(6.3)返回7。 |
floor(x) | 返回数值x的下舍整数。 |
例如,一起来完成:
(1)使用from - import导入math模块的几个功能;
(2)求解3.14的上入整数;
(3)求解3.14的下舍整数。
# 1.导入模块
from math import ceil,floor
# 2.上入
print(ceil(3.14))
# 3.下舍
print(floor(3.14))
==总结:==
(1)当要使用某模块中的几个功能时,可以使用【from 模块名 import 功能1[, 功能2, 功能3...]】一次导入。
[了解]from xx import *
==目标:==了解from xx import *的使用。
from xx import *导入模块语法:
from 模块名 import *
说明:
表示导入所有功能。
例如,一起来完成:
(1)使用from - import *导入模块;
(2)求解8的平方根、10^3^的值;
(3)思考:若要使用π,可以怎么做?
# 1.导入所有
from math import *
# 2.使用
print(sqrt(8)) #? 疑问
print(pow(10,3))
# 3.思考?
print(pi) # 1.不好阅读程序; 2.采用导入所有的形式会影响性能
print(e)
==总结:==
(1)在Python语言中,*通常表示();==A、所有==;B、某一个;
(2)注意:不推荐使用from xx import *导入模块,因为导入模块中所有功能时,加载缓慢。
[了解]导入模块的别名
==目标:==了解如何取别名。
导入模块时,也可以给模块或功能取别名,语法:
import 模块名 as 别名 from 模块名 import 功能 as 别名
例如,一起来完成:
(1)使用math模块来求解2^10^的值、9的平方根;
(2)分别给import和from - import取别名来导入模块,并完成求结果;
(3)思考:若还想要使用模块名的形式来求解16的平方根,该怎么做呢?
# 1.导入模块 import
# 2.from -import
import math as m # 给模块起别名
from math import sqrt as sq # 给模块下的函数起别名
from math import pow as po # 给模块下的函数起别名
import math # 重新导入
print(m.sqrt(9))
print(m.pow(2,10))
print(sq(9))
print(po(2,10))
# 3.模块名
print(math.sqrt(16))
==总结:==
(1)当取了别名后,则只能使用别名来调用功能或函数;
(2)注意:给导入的模块取别名时,语法是:() 别名。A、with;==B、as==;
制作模块
[掌握]定义与调用模块
==目标:==掌握定义与调用模块的使用。
有时候,模块也称为库,当一个模块具有强大功能时,也可称为框架。
在Python中,模块分为三类:
(1)自定义模块:定义后,直接使用;
(2)标准库:直接导入使用;
(3)扩展库(第三方库):需要先安装库,然后再使用。
通常地,每个Python文件都可以作为一个自定义模块而存在。
而开发者可以给自定义模块完成某些特定功能,比如求和、验证是否登录成功等等。
注意:给模块名取名时,建议所有字母均小写。
例如,一起来完成:
(1)新建一个Python文件,命名为mytool.py
;
(2)在模块中,定义add()
函数用于求解两数之和;
(3)接着,再定义一个模块来调用mytool.py
下的add()
函数求和。
# 定义函数
def add(a, b):
c = a + b
print(f"两数之和为:{c}")
# 1.导入自定义模块名
import mytool
# 2.调用函数
mytool.add(10,20)
==总结:==
(1)当一些功能比较通用且频繁使用时,可以采用自定义的形式把功能进行封装在自定义模块中;
(2)注意:自定义模块名不要与Python已有库名相同,否则会出错。
[了解]__name__
变量
==目标:==了解
__name__
变量的使用。
我们知道,为了提升程序的稳定性。当编写完一个自定义模块的功能后,需要在模块中添加一些测试代码。
而当再另一个模块中调用自定义模块时,会发现:刚刚添加的测试代码也会一并执行。该怎么解决呢?
说明:
此时,就要来了解__name__
变量的使用。
注意:每个模块中都有的__name__
变量,语法:
(1)当__name__在当前模块下测试输出结果:__main__ (2)当在另外的模块里调用输出时,结果:当前模块名
通常地,在测试代码时,需要添加判断__name__
变量的语法:
if __name__ == "__main__": 代码 ...
说明:
前后是双下划线。
例如,一起来完成:
(1)拷贝mytool.py
文件,并取名mytool2.py
;
(2)给mytool2.py
文件添加测试代码,测试求和效果;
(3)在另一个模块中调用求和函数,观察效果;
(4)思考:该怎么解决这个问题呢?
# 定义函数
def add(a, b):
c = a + b
print(f"两数之和为:{c}")
# if __name__ == "__main__":
# print(__name__) # 当前: __main__
# # 测试
# add(199,100) # 测试
# main + Enter
if __name__ == '__main__':
add(199, 100)
# 1.导入自定义模块名
import myutil # __name__: myutil
# 2.调用函数
myutil.add(10,20)
==总结:==
(1)请问:在调用执行代码时,建议放在
if __name__ "__main__":
下,这句话正确吗?==A、正确==;B、错误。
[了解]__all__
变量
==目标:==了解
__all__
变量的使用。
当一个模块文件中有__all__
变量,当使用from xxx import *
导入时,只能导入这个列表中的元素。
语法:
__all__ = ["函数名1","函数名2",xxx]
说明:
可以使用__all__
变量来限定*的范围。
例如,一起来完成:
(1)定义myutil.py
模块,有4个函数:求和、求差、求积、求商;
(2)在myutil.py
模块中定义__all__
变量,只能使用求和、求差功能;
(3)观察使用from xxx import *
导入后的调用效果。
# 限定*的行为
__all__ = ["get_he","get_cha"]
# 求和
def get_he(a,b):
c = a + b
return c
# 求差
def get_cha(a,b):
c = a - b
return c
# 求商
def get_shang(a,b):
c = a / b
return c
# 求积
def get_ji(a,b):
c = a * b
return c
from helloutil import *
print(get_he(10,90))
print(get_cha(10,90))
# print(get_shang(10,90)) # 限定行为
# print(get_ji(10,90))
==总结:==
(1)当要限定*仅能导入某几个功能时,可以使用
__all__
变量,但使用较少;(2)
__all__
变量的类型是()。==A、列表==;B、字符串。
[了解]制作Python包
==目标:==了解如何制作Python包?
当在一个文件夹下,创建了一个名字为__init__.py
的模块文件,那么,这个文件夹就叫做:Python包。
Python包可以将一些有联系的模块放在一起,即放到同一个文件夹下,这样更加便于管理。
需要注意:当制作完Python包后,使用包下的模块语法:
from 包名 import 模块名, xxx
例如,一起来完成:
(1)手动创建一个文件夹,并在文件夹中,新建一个__init__.py
文件;
(2)思考:还有其他方式制作Python包吗?
==总结:==
(1)Python包与普通的目录区别在于:Python包中会默认有一个
__init__.py
模块;(2)一般地,会在
__init__.py
模块做一些初始化操作,比如初始化MySQL、初始化数据等。
常见的模块
[了解]time模块
==目标:==了解time模块的使用。
time模块表示时间日期,常用函数:
函数名 | 含义 |
---|---|
sleep(t) | 休眠,即延迟运行,注意参数t的单位为秒(s)。 |
time() | 返回时间戳,即当前时间秒数(与1970年1月1日午夜之间的时间差)。 |
例如,一起来完成:
(1)导入time模块;
(2)模拟出5-1的倒序,且每隔1s后输出一个数字的倒计时样式。
# 导入模块
from time import sleep, time
# 获取从1970年到当前的秒值
print(time())
# 延迟函数
while True:
sleep(1) # 程序执行到这里就会休眠一秒钟,然后醒来,继续执行
print('我爱你中国!')
==总结:==
(1)当要延时处理时,可以快速使用time模块的()函数。==A、sleep()==;B、wait()。
[掌握]动态抽奖案例
==目标:==掌握动态抽奖案例的编写。
例如,一起来完成:
(1)使用所学知识来完成一个动态抽奖系统案例;
(2)使用文件操作、模块知识来配合完成获取学生名单;
(3)注意:学生信息来源于班级学生名单.txt
。
# 1.导入模块
import random
import time
# 2.读取学生名单文件
with open("学生名单.txt","r",encoding="utf-8") as file:
# 3.获取学生名单列表
texts = file.read()
# 切割
student_lists = texts.split("\n")
# print(student_lists)
# 4.动态获取列表索引
index = random.randint(0, len(student_lists)-1)
# 5.倒序输出
i = 5
while i > 0:
print(i)
time.sleep(1)
i -= 1
# 6.学生结果
print(f"抽取结果为:{student_lists[index]}")
# 1.导入模块
import random
import time
def my_sleep():
i = 5
while i > 0:
print(i)
time.sleep(1)
i -= 1
# 2.读取学生名单文件
with open("学生名单.txt","r",encoding="utf-8") as file:
# 3.获取学生名单列表
texts = file.read()
# 切割
student_lists = texts.split("\n")
for i in range(3):
index = random.randint(0, len(student_lists) - 1)
my_sleep()
# 6.学生结果
print(f"第{i+1}个幸运学生为:{student_lists.pop(index)}")
print('抽奖结束!')
==总结:==
(1)在实际应用中,若要动态获取数据,则可以直接使用随机数值去表示。