目录

1. os、pathlib
2. sys
3. random
4. time、datetime
5. math
6. json
7. re (掌握最后2个示例就行)

Python 为我们内置了很多有用的库。

一、os、pathlib

os 提供了通用的、基本的操作系统交互功能,常用的有:路径操作、进程管理、环境参数等。

1.1 进程管理

1.2 环境参数

1.3 其它

1.4 路径操作

路径操作,主要使用了 os.path 子库,用于处理文件路径及信息。

关于 __file__ 当前 python 脚本的运行路径,用相对路径执行时,__file__ 是相对路径;用绝对路径执行时,__file__ 是绝对路径。 被导入的模块内的 __file__ 都是绝对路径。

1.5 pathlib

os.path 的替代

pathlib 库从 Python3.4 版本引入,到 Python3.6 已经很成熟了。如果是新项目,可以使用 pathlib 替换 os.path 子库。

from pathlib import Path p = Path(__file__) print(p.absolute()) # 获取绝对路径 print(p.resolve()) # 获取绝对路径,如果是软链接则直接被解析,推荐使用 print(p.name) # 获取文件名称 print(p.stem) # 只要文件名,不要后缀 print(p.suffix) # 获取文件后缀 print(p.suffixes) # 获取所有文件后缀 print(p.parent) # 获取文件所在的目录 print(Path.home()) # 获取用户 home 目录 print(p.is_file()) # 判断 path 对应的是否为已存在的文件,返回 True / False print(p.is_dir()) # 判断 path 对应的是否为已存在的目录,返回 True / False print(p.exists()) # 判断 path 对应的文件或者目录是否存在,返回 True / False print(p.is_absolute()) # 判断是否是绝对路径 # 拼接路径 print(p.parent.joinpath('hello', 'world')) print(p.parent / 'hello' / 'world') print(list(p.parent.iterdir())) # 遍历目录 # 模式匹配查找 print(p.parent.glob('*.py')) # 查找当前目录下所有以 .py 结尾的文件 print(p.parent.rglob('*.py')) # 会递归子目录查找 p = Path('xxx.json') p.touch() # 创建文件,当文件已经存在的时候,p.touch() 也不会报错,因为默认参数 exist_ok=True。 p = Path('dir') p.mkdir() # 创建目录 p = Path('dir/sub') p.mkdir() # 创建目录,目录不存在的话,会报错。 Path('dir/sub').rmdir() # 删除 dir 下的 sub 目录,如果 sub 不是空目录,则会删除失败 # shutil.rmtree Path('xxx.json').unlink() # 删除文件,文件不存在会抛出异常。

练习: 自己实现一个删除文件夹的功能。

二、sys

当 import 某个模块时,解释器首先搜索具有该名称的内置模块,如果没有找到,将在变量 sys.path 给出的目录列表中搜索名为 模块名.py 的文件。 sys.path 包含了一下几个目录: 输入脚本的当前目录; PYTHONPATH环境变量; python安装目录;

三、random

生成随机浮点数、整数、字符串,甚至帮助你随机选择列表序列中的一个元素,打乱一组数据等。

四、time、datetime

4.1 time

提供各种与时间相关的函数。 在计算机中,时间实际上是用数字表示的。把 1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time,记为0(1970年以前的时间timestamp为负数)。 当前时间就是相对于 epoch time 的秒数,称为timestamp(时间戳)。

4.2 datetime

4.2.1 datetime 类型拥有的属性/方法

注意:时间戳是没有时区概念的,datetime 是有时区概念的

4.2.2 datetime 的运算 -> timedelta

五、math

六、json

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式,易于人阅读和编写。

七、re (掌握最后2个示例就行)

该模块中提供的很多功能是基于正则表达式实现的,而正则表达式是对字符串进行模糊匹配,提取自己需要的字符串部分,它对所有的语言都通用。

注意:

- re模块是python独有的
- 正则表达式所有编程语言都可以使用
- re模块、正则表达式是对字符串进行操作

因为,re模块中的方法大都借助于正则表达式,故先学习正则表达式。

常用正则

1、字符组

在同一个位置可能出现的各种字符组成了一个字符组,在正则表达式中用 [] 表示

正则              待匹配字符           匹配结果            说明
[0123456789]        8                 True           在一个字符组里枚举合法的所有字符,字符组里的任意一个字符和"待匹配字符"相同都视为可以匹配
[0123456789]        a                 False          由于字符组里没有"a"字符,所以不能匹配
[0-9]               7                 True           也可以用-表示范围,[0-9]和[0123456789]是一个意思
[a-z]               s                 True           如要匹配所有小写字母,用[a-z]来表示
[A-Z]               B                 True           [A-Z]表示所有的大写字母
[0-9a-fA-F]         e                 True           可匹配数字,大小形式的a~f,用来验证十六进制字符

2、元字符

元字符             匹配内容
 .                匹配除换行符以外的任意字符
 \w               匹配字母或数字或下划线
 \s               匹配任意的空白符
 \d               匹配数字
 \n               匹配一个换行符
 \t               匹配一个制表符
 \b               匹配一个单词的结尾
 ^                匹配字符串的开始
 $                匹配字符串的结尾
\W                匹配非数字、非字母、非下划线
\D                匹配非数字
\S                匹配非空白符
a|b               匹配字符a或字符b
()                匹配括号内的表达式,也表示一个组
[...]             匹配字符组中的字符
[^...]            匹配除了字符组中字符的所有字符

3、量词

量词          用法说明
 *          重复零次或更多次(也就是任意次)
 +          重复一次或更多次(也就是至少1次)
 ?          重复零次或一次
 {n}        重复n次
 {n,}       重复n次或更多次
 {n,m}      重复n到m次

默认情况下,* + 是贪婪匹配,也就是尽可能匹配的多些,后面加 ? 号使其变成惰性匹配

正则      待匹配字符       匹配结果        说明
a.*?      abefacgad       a             惰性匹配

分组() 与 | [^] 身份证号码是一个长度为15或18个字符的字符串,如果是15位则全部由数字组成,首位不能为0;如果是18位,则前17位全部是数字,末尾可能是数字或x。

正则                              待匹配字符               匹配结果                说明
^[1-9]\d{13,16}[0-9x]$           110101198001017032      110101198001017032     表示可以匹配一个正确的身份证号
^[1-9]\d{13,16}[0-9x]$           1101011980010170        1101011980010170       也能匹配这串数字,但这并不是一个正确的身份证号,它是一个16位的数字
^[1-9]\d{14}(\d{2}[0-9x])?$      1101011980010170        False                  ()表示分组,将\d{2}[0-9x]分成一组,就可以整体约束他们出现的次数为0-1次
^[1-9]\d{16}[0-9x]$|[1-9]\d{14}$ 110105199812067023      110105199812067023     表示先匹配[1-0]\d{16}[0-9x],如果没有匹配上就匹配[1-9]\d{14}

转义符

在正则表达式中,有很多有特殊意义的是元字符,比如\n和\s等。如果要在正则中匹配正常的"\n"而不是"换行符"就需要对""进行转义,变成"\"。

在python中,无论是正则表达式,还是待匹配的内容,都是以字符串的形式出现的,在字符串中\也有特殊的含义,本身还需要转义。所以如果匹配一次"\n",字符串中要写成'\n',那么正则里就要写成"\\n",这样就太麻烦了。这个时候我们就用到了r'\n'这个概念,此时的正则是r'\n'就可以了。

正则          待匹配字符           匹配结果            说明
\n           \n                  False             正则表达式中\是有特殊意义的字符,所以要匹配\n本身,用表达式\n无法匹配
\\n          \n                  True              转义\之后变成\\,即可匹配
"\\\\n"      '\n'                True              如果在Python中,字符串中的'\'也需要转义,所以每一个字符串'\'又需要转义一次
r"\\n"       '\n'                True              在字符串之前加r,让整个字符串不转义

贪婪匹配

在满足匹配时,匹配尽可能长的字符串,默认情况下,采用贪婪匹配。

正则      待匹配字符               匹配结果                 说明
<.*>     <script>...<script>     <script>...<script>    默认为贪婪匹配模式,会匹配尽量长的字符串
<.*?>    <script>...<script>     <script>               加上?,将贪婪匹配模式转为非贪婪匹配模式,会匹配尽量短的字符串

几个常用的非贪婪匹配 Pattern

*? 重复任意次,但尽可能少重复
+? 重复1次或更多次,但尽量少重复
?? 重复0次或1次,但尽可能少重复
{n,m}? 重复n到m次,但尽可能少重复
{n,}?  重复n次以上,但尽可能少重复

.*? 的用法

. 是匹配任意字符
* 是取0至无限长度
? 是非贪婪模式
合在一起就是,取尽量少的任意字符,一般不会这么单独写,它大多用在: .*?x 就是取前面任意长度的字符,直到一个x出现。

常用方法

match 对象 re.match, re.search 方法返回 match 对象。

import re a = "123abc456" print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0)) #123abc456,返回整体 print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1)) #123 print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2)) #abc print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3)) #456 # group() 同group(0)就是匹配正则表达式整体结果 # group(1) 列出第一个括号匹配部分,group(2) 列出第二个括号匹配部分,group(3) 列出第三个括号匹配部分。
# 掌握这里的几种用法就够了。 import re class Replace: def __init__(self, data, pattern=r'\${(.+?)}'): self.regex = re.compile(pattern) self.data = data def __replace(self, match): return str(self.data[match.group(1)]) def replace(self, string): return re.sub(self.regex, self.__replace, string) result = Replace( { 'name': 'Hugh', 'age': 30 } ).replace('https://baidu.com?name=${name}&age=${age}') print(result) print(re.split(r',\s*', 'a, b,c, d, e')) # ['a', 'b', 'c', 'd', 'e']