python基础语法7，库的基本知识（简单易上手的python语法教学）-优快云博客

import time              # 导入整个time库，后续用time.xxx调用库内功能
from time import sleep   # 仅导入time库的sleep函数，可直接用sleep()
from time import *       # 导入time库所有函数，函数可直接调用，易引发命名冲突
import time as t         # 给time库设别名t，后续用t.xxx调用，方便简化代码

3、Python 内部设置的 3 个优先搜索路径

当使用 from 和 import 组合方式导入模块（如 time.py）时，Python 解释器会按以下步骤依次搜索：

1.优先搜索代码所在文件夹
检查当前运行的代码文件所在目录中，是否存在名为 time.py 的文件。若存在，则直接导入该文件中的模块。

2.搜索 Python 安装目录下的标准库路径
若代码所在文件夹中不存在目标文件，Python 会继续搜索其安装路径下的 Lib 目录（即标准库路径）。

3.搜索第三方库安装路径
若标准库路径中仍未找到，Python 会最后搜索 Lib 目录下的 site-packages 文件夹（即第三方库安装路径）。
注意：创建文件时，文件名不要和标准库的文件名相同，会冲突

二、时间库

1、获取时间戳。

时间戳是当前时间与 1970 年 1 月 1 日 0 时 0 分 0 秒的时间差（单位：秒）。通过 import time 导入时间库后，用 time.time() 获取，示例代码：

import time
a = time.time()
print(a) 
#1752146520.3103764

2、print 语句（I/O 影响演示）

1、含 print 语句的代码（耗时久）

import time
start = time.time()
i = 1
while i < 10000000:
    i += 1
    print(i)
end = time.time()
print('代码启动时间:',start,'\n停止时间:',end,'\n执行时间:',end - start)
# 代码启动时间: 1752146359.57038
# 停止时间: 1752146389.9952068
# 执行时间: 30.424826860427856

运行后耗时约 1068.2438850402832 秒，因 print 需将数据输出到界面，涉及 CPU 进行 I/O（输入输出）操作，极为损耗资源。

2. 不含print 语句的代码（耗时短）运行后耗时约 `68.09210014343262` 秒，数据写入文本文件，相比输出到界面，I/O 操作对 CPU 资源消耗大幅降低。

结论：print 语句因涉及界面输出，耗费资源多，写代码应尽量减少使用。

3、获取时间

1、`localtime()` 函数

用于获取本地当前时间，返回 struct_time 数据对象（类似元组，含年、月、日等时间元素）。示例代码：

import time
a = time.localtime()
print(a)
print(list(a))
b = time.localtime(1622874693.6661327)
print(b) 
# time.struct_time(tm_year=2025, tm_mon=7, tm_mday=10, tm_hour=19, tm_min=36, tm_sec=9, tm_wday=3, tm_yday=191, tm_isdst=0)
# [2025, 7, 10, 19, 36, 9, 3, 191, 0]
# time.struct_time(tm_year=2021, tm_mon=6, tm_mday=5, tm_hour=14, tm_min=31, tm_sec=33, tm_wday=5, tm_yday=156, tm_isdst=0)

2、gmtime() 函数

用于获取 UTC（世界协调时，即世界标准时间），中国为东八区（UTC + 8 ）。使用形式 time.gmtime(seconds=None) ，seconds 为 None 时取当前 UTC 时区（0 时区）时间，也可传入时间戳转换。示例代码：

import time
a = time.gmtime()  # 获取当前 UTC 时间
print(a)
b = time.gmtime(1622874693.6661327)  # 将指定时间戳转换为 UTC 时间
print(b)
# time.struct_time(tm_year=2025, tm_mon=7, tm_mday=10, tm_hour=11, tm_min=36, tm_sec=51, tm_wday=3, tm_yday=191, tm_isdst=0)
# time.struct_time(tm_year=2021, tm_mon=6, tm_mday=5, tm_hour=6, tm_min=31, tm_sec=33, tm_wday=5, tm_yday=156, tm_isdst=0)

3、`ctime()` 函数

功能：将时间戳转换为字符串形式的本地时间

import time
a = time.ctime()  # 获取当前时间的字符串表示
print(a)
b = time.ctime(1622874693.6661327)  # 将指定时间戳转换为字符串表示
print(b)
# Thu Jul 10 19:38:47 2025
# Sat Jun  5 14:31:33 2021

4、时间格式转换

1、`mktime()` 函数

功能：将 struct_time 对象转换为时间戳。

import time
t = time.localtime()  # 获取当前本地时间的 struct_time 对象
struct_time = time.mktime(t)  # 转换为时间戳
print(struct_time)
#1752147699.0

2、 `strftime()` 函数

功能：将 struct_time 对象转换为格式化字符串

import time
t = time.localtime()  # 获取当前本地时间
struct_time  = time.strftime('%Y-%m-%d %H:%M:%S', t)  # 格式化为 YYYY-MM-DD HH:MM:SS
print(struct_time)
#2025-07-10 19:48:16

参数format:根据format格式定义输出时间

格式化字符表：

格式化字符串	解释（含义）	值的范围	示例
%Y	年份（四位数字）	0001-9999	2025
%m	月份（两位数字）	01-12	07
%b	缩写月份名称（英文）	无固定范围（随语言）	Jul
%B	完整月份名称（英文）	无固定范围（随语言）	July
%d	日期（两位数字）	01-31	09
%A	完整星期名称（英文）	无固定范围（随语言）	Wednesday
%a	缩写星期名称（英文）	无固定范围（随语言）	Wed
%H	小时（24 小时制，两位数字）	00-23	15
%I	小时（12 小时制，两位数字）	01-12	03
%p	上下午标识（英文）	AM/PM	PM
%M	分钟（两位数字）	00-59	30
%S	秒（两位数字）	00-59	45

3、 `strptime()` 函数

功能：将一个格式化的时间字符串解析为 struct_time 对象。

import time
a = time.strptime('2021-09-30', '%Y-%m-%d')
print(a) 
#time.struct_time(tm_year=2021, tm_mon=9, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=273, tm_isdst=-1)

5、时间休眠

功能：让程序暂停执行指定秒数，用于控制代码执行节奏，常用来模拟延迟、控制请求的频率等场景。

参数说明：为休眠时长，支持整数或小数，单位是秒。

import time
time.sleep(10)
print('此消息 5 秒后输出')
#此消息 5 秒后输出(五秒后才发出的）

三、随机库

1、随机生成数值

在 random 库中，可通过以下方法随机生成数值，使用前需用 import random 导入库。

1. uniform() 方法

函数形式：random.uniform(参数1, 参数2)
功能：生成参数 1 到参数 2 之间的随机小数，参数为数值类型。

import random
a = random.uniform(1, 5)
print(a)
#输出2.474854868378847

2.、`random()` 方法

函数形式：random.random()

功能：生成 0 - 1（不包含 1 ）的随机小数，无需传入参数。

import random
a = random.random()
print(a) 
#0.2710401080680864

3、`randint()` 方法

函数形式：random.randint(参数1, 参数2)

功能：生成参数 1 到参数 2 之间的整数。

import random
a = random.randint(2, 9)
print(a) 
#输出4

4、`randrange()` 方法

函数形式：random.randrange(参数1, 参数2, 参数3)

功能：生成在参数 1 到参数 2 之间，且步长为参数 3 的随机整数。

import random
a = random.randrange(0, 20, 5)
print(a) 
#输出5

2、随机选择

random 库的以下函数，可从序列类型数据（如列表、字符串）中随机选元素。

1、`choice()` 函数

函数形式：random.choice(参数)

功能：从参数（序列类型，可通过索引取值）中随机选一个元素。

import random
ls = ['一等奖', '二等奖', '三等奖', '谢谢惠顾']
a = random.choice(ls)
print(a) 
#输出 二等奖

运行后从列表 ls 随机选一个元素输出，如 二等奖 ，每次结果可能不同。

2、`shuffle()` 函数

函数形式：random.shuffle(参数)

功能：将参数（序列类型数据）中的元素随机打乱顺序。

import random
ls = ['一等奖', '二等奖', '三等奖', '谢谢惠顾']
random.shuffle(ls)
print(ls) 
#输出['谢谢惠顾', '三等奖', '二等奖', '一等奖']

运行后列表 ls 元素顺序被随机打乱，如 ['一等奖', '三等奖', '谢谢惠顾', '二等奖'] 。

3、`sample()` 函数

函数形式：random.sample(参数1, 参数2)

功能：从参数 1（序列类型数据）中随机选取参数 2 个元素，参数 2 为整数。

import random
ls = ['一等奖', '二等奖', '三等奖', '谢谢惠顾']
a = random.sample(ls, 2)
print(a)
#输出['二等奖', '谢谢惠顾']

3、随机种子

seed() 函数

函数形式：random.seed(种子)

功能：设置随机种子，让下一次随机获取的值由该种子确定，使随机结果可复现；种子可为整数、字符串等数据类型。

import random
ls = ['一等奖', '二等奖', '三等奖', '谢谢惠顾']
random.seed('张三')
print(random.choice(ls))
random.seed('王五')
print(random.choice(ls)) 
# 输出
# 二等奖
# 谢谢惠顾

四、正则表达式库

正则表达式是一种表达式语句，用于对字符串类型数据进行操作，涵盖从字符串里筛选出满足表达式条件的信息、替换字符串内容等功能。在 Python 里，正则表达式由re库实现，使用前需通过import导入。

1、匹配字符串

匹配字符串指从字符串中筛选出满足条件的信息，条件需用正则表达式这种特殊表达式来表示。本小节介绍re库中 3 种匹配字符串的方法，即match()函数、search()函数和findall()函数。

1. match () 函数

match()函数使用形式：

match(参数1, 参数2)

import re
message = '张三、李四、王五、赵六'
result = re.match('张三', message)
print(result)
#输出<re.Match object; span=(0, 2), match='张三'>

返回结果为正则类型，span=(0,2)指明匹配位置（字符串索引 0 - 2），匹配内容是'张三'。修改代码如下：

import re
message = '张三、李四、王五、赵六'
result = re.match('三', message)
print(result)
#输出None

执行后返回None，虽'三'在message中，但不在开头，匹配失败。

2、 search () 函数

search()函数使用形式：
search(参数1, 参数2)

功能：从参数 2（字符串类型数据）查找符合参数 1（正则表达式）的内容，匹配多个时，仅返回第 1 个匹配成功的信息。

示例代码：

import re
message = '张三、李四、王五、赵六、王五'
result = re.search('王五', message)
print(result)
#输出<re.Match object; span=(6, 8), match='王五'>

第 3 行代码用search()从message匹配'王五' ，message有两个'王五'，执行后输出第 1 个'王五'的位置和内容。

3、findall () 函数

findall()函数使用形式：
findall(参数1, 参数2)

功能：从参数 2（字符串类型数据）查找符合参数 1（正则表达式）的内容，匹配多个时，返回所有匹配成功的信息。

import re
message = '张三、李四、王五、赵六、王五'
result = re.findall('王五', message)
print(result)
#输出：['王五', '王五']

findall()不返回匹配位置，只返回全部匹配内容。

2、正则表达式

（一）小节的match()、search()、findall()函数，参数 1 为字符串，未涉及正则表达式。正则表达式是用特殊符号表示字符串规则的方式，本小节从字符范围、字符出现次数等方面介绍。

1. 表示字符范围
[xyz]：字符集合，匹配包含的任意一个字符。如[abc]可匹配plain里的a 。
[a-z]：字符范围，匹配指定范围内任意字符。如[a-z]匹配a到z范围的小写字母。

import re
message = 'Python93,C#7,Java63,C++88'
result_1 = re.search('[cn]', message)
result_2 = re.findall('[0-9]', message)
result_3 = re.findall('[cn][0-9]', message)
print(result_1, result_2, result_3)
#输出：<re.Match object; span=(5, 6), match='n'> ['9', '3', '7', '6', '3', '8', '8'] ['n9']

第 3 行：从message匹配字符c或n，有则输出匹配到的第 1 个字符。
第 4 行：匹配0 - 9的任意数字，因用findall()，输出message里全部数字。
第 5 行：正则表达式含[cn][0-9]，需匹配两个字符，第 1 个是c或n，第 2 个是数字。

2. 表示字符出现的次数
*：匹配前面子表达式任意次（≥0 次）。如zo*匹配"z"、"zo"、"zoo" ，等价于{0,}。
+：匹配前面子表达式 1 次或多次。如zo+匹配"zo"、"zoo" ，不匹配"z"，等价于{1,}。
?：匹配前面子表达式 0 次或 1 次。如do(es)?匹配"do"或"does" ，等价于{0,1}。
^：匹配输入行首。
$：匹配输入行尾。
{n}：匹配n次，n为非负整数。如o{2}不匹配"Bob"里的"o" ，匹配"food"里的两个"o"。
{n,}：至少匹配n次，n为非负整数。如o{2,}不匹配"Bob"里的"o" ，匹配"foooood"里所有"o"，等价于"o+"；o{0,}等价于"o*"。
{n,m}：最少匹配n次且最多匹配m次，m、n为非负整数且n≤m 。如o{1,3}匹配"foooood"里前 3 个"o"和后 3 个"o"；o{0,1}等价于"o?" ，逗号和数字间不能有空格。

import re
message = 'da2a7df77tcfed777tb,4dbre7y2fed777tcfed777tb'
result = re.findall('[a-z]*[0-9][a-z]', message)
print(result)
#输出：['da2a', '7d', '7t', '7t', '4d', 'bre7y', '2f', '7t', '7t']

第 3 行正则表达式[a-z]*[0-9][a-z]中，*前为[a-z]，匹配a - z范围任意字符，可出现任意次；[0-9]匹配数字；[a-z]匹配a - z字母。整体表示匹配最后一个字符是a - z字母，倒数第 2 个字符是数字的内容。

示例

1、验证手机号码正确性

import re
phone_num = input("请输入您的手机号码:")
result = re.findall('^1[0-9]{10}$', phone_num)
print(result)
# 输出
# 请输入您的手机号码:13777772
# []
# 请输入您的手机号码:19360244404
# ['19360244404']

2、验证是否为QQ号

import re
QQ_number = input("请输入您的QQ号：")
result = re.match('[1-9][0-9]{4,10}$',QQ_number)
print(result)
# 输出
# 请输入您的QQ号：3125324963
# <re.Match object; span=(0, 10), match='3125324963'>
# 请输入您的QQ号：7432
# None

表示同一类字符

\d：匹配一个数字类字符，等价于[0-9]。
\D：匹配一个非数字类字符，等价于[^0-9]。^在方括号中表示非，即不匹配输入字符的首位字符。
\s：匹配任何不可见字符，包括空格、制表符、分页符等，等价于[f\n\r\t\v]。
\S：匹配任何可见字符，等价于[^\f\n\r\tlv]
w：匹配包括下画线的任何单词字符，等价于"[A-Za-z0-9_]"。
\W：匹配任何不包括下画线的非单词字符，等价于"[^A-Za-z0-9_]"
\b：匹配一个单词的边界，即单词中与空格邻接的字符。
\B：匹配非单词边界。例如"er\B"能匹配"verb"中的"er"，但不能匹配"never"中的"er"，因为“er"是
"never"的单词边界。
\f：匹配一个分页符。
\n：匹配一个换行符。
\r：匹配一个回车符。
\t：匹配一个制表符。
\v：匹配一个垂直制表符。
.：匹配除"n"和"r”之外的任何单个字符。

示例代码（验证用户名的正确性）：

import re
use_name = input("请输入您的用户名：")
result = re.findall('^[A-Za-z_]\w{7,}$',use_name)
print(result)
# 输出
# 请输入您的用户名：chaoxing1234
# ['chaoxing1234']

import re
message = 'verb very never every'
result = re.findall(r'\w+er\B',message)  #\b是转义字符
print(result)
# 输出
# ['ver', 'ver', 'ever']

import re
message = 'verb very never every'
result = re.findall('.e',message)
print(result)
# 输出
# ['ve', 've', 'ne', 've', ' e', 've']

3、贪婪和非贪婪模式

贪婪模式：默认匹配模式都是贪婪模式，匹配形式是尝试匹配尽可能多的字符，只要满足表达式要求都会匹配最多的字符
非贪婪模式：匹配形式是尝试匹配尽可能少的字符，一旦满足表达式要求就不再继续匹配。在次数限制操作符后面加上“?”可以将匹配模式转换为非贪婪模式

贪婪模式：

import re
message = 'ccc739134792hd'
result = re.findall('ccc\d+',message)
print(result)
# 输出
# ['ccc739134792']

非贪婪模式：

import re
message = 'ccc739134792hd'
result = re.findall('ccc\d+?',message)
print(result)
# 输出
# ['ccc7']

4、或和组

'''用“|”表示，表示将两个匹配条件进行逻辑“或（or）”运算'''

import re
message = 'verb very never every'
result = re.findall('\w+ev|\w+ry',message)
print(result)
# 输出
# ['very', 'nev', 'every']

'''将()中的表达式定义为组，并且将匹配这个表达式的字符保存到一个临时区域'''

import re
message = 'verb very never every'
result = re.findall("e(.+)(.)r",message)
print(result)
# 输出
# [('rb very never ev', 'e')]

5.sub（）和compile（）方法

sub（参数1，参数2，参数3）
#功能：将字符串3中所有与参数1匹配的字符替换为参数2.

import re
content ='dh932hf9f934hfnf39d'
content = re.sub('\d','0',content)
print(content)
# 输出
# dh000hf0f000hfnf00d

sub() 主要功能是基于正则表达式对字符串中的特定模式进行搜索，然后用指定的内容替换这些匹配到的模式。

import re
contentl ='2020 12 15 12:00'
pattern = re.compile('\d{2}:\d{2}')
print(pattern.findall(contentl))
# 输出
# ['12:00']

compile()方法用于创建一个正则表达式对象，可以直接使用正则表达式对象的方法匹配其他内容

python基础语法7，库的基本知识（简单易上手的python语法教学）

一、标准库

1、标准库介绍

2、标准库导入方法