标签：最新 sdi function 划线 等等 好的 结构 aci hat
第1章 模块
1.1 概述
1.2 模块的分类
1.2.1 内置模块
1.2.2 扩展模块
1.2.3 模块安装
1.2.4 自定义模块
第2章 模块之内置模块
2.1 collections模块
2.1.1 collections数据类型
2.1.2 nametuple
2.1.3 可命名元组
2.1.4 queue 模块
2.1.5 Ordereddict有序字典
2.1.6 defaultfict 默认字典
2.2 time模块
2.2.1 sleep
2.3 时间的表示格式
2.3.1 时间戳(timestamp)
2.3.2 格式化时间(Format String)
2.3.3 元组(struct_time)
2.3.4 时间戳的转化
2.3.5 字符串时间的转化方法
2.4 random
2.4.1 随机小数
2.4.2 随机整数
2.4.3 打乱列表顺序
2.4.4 随机练习：验证
2.4.5 练习题:抢红包
2.5 sys模块
2.5.1 定义
2.5.2 调用方法
2.5.3 ****sys.path
2.5.4 sys.platform
2.5.5 sys.version
2.5.6 sys.modules
2.5.7 sys.exit()
2.5.8 sys.argv
2.6 os模块
2.6.1 os参数整理
2.6.2 os.getcwd
2.6.3 __file__
2.6.4 os.chdir
2.6.5 os.stat(‘path/filename‘)
2.6.6 os.path.getsize
2.6.7 目录大小统计练习
2.7 re模块
2.7.1 解释：
2.7.2 规则：
2.7.3 字符组
2.7.4 字符：
2.7.5 量词：
2.7.6 . ^ $
2.7.7 * + ? { }
2.7.8 字符集[][^]
2.7.9 分组 ()与 或 ｜［^］
2.7.10 转义符 \
2.7.11 贪婪匹配
2.7.12 常用的非贪婪匹配Pattern
2.7.13 +?
2.7.14 .*?的用法
2.7.15 re模块应用
2.7.16 正则应用
2.7.17 惰性匹配
2.7.18 search找一个
2.7.19 分组优先
2.7.20 search中没有分组优先
2.7.21 ？的用法
第3章 拾遗
3.1 进度条
n 解释：python有很多现成的函数方法，但这些函数不能都放在内存里，为用户节省很多不必要的内存消耗，用不到的内容就不用导入内存中。
n 定义：一组python或c语言的代码；一堆写好的函数或者类
n 以功能来分类
解释：随着Python解释器的安装运行直接可以使用
解释：需要自己安装才能使用如：Django itchat
pip3 install diango
解释：用户根据自己的?完成的一组功能
解释：使用前必须先导入，已知的所有模块名都不可以作为python文件名
导入模块
import collections
每一个类都是一个数据类型
例：
a = ‘a‘
实际上是对象的实例化：
a = str(‘a‘)
collections模块在内置数据类型基础上还提供了额外的几个数据类型：Counter、deque、deque、defaultdicr、namedtupe 和OrderedDictd等
l namedtuple: 生成可以使用名字来访问元素内容的tuple
l deque: 双端队列，可以快速的从另外一侧追加和推出对象
l Counter: 计数器，主要用来计数
l OrderedDict: 有序字典
l defaultdict: 带有默认值的字典
解释：生成可以使用名字来访问元素的tuple
实例1）求根号
from math import sqrt
p = (1,2)
print(sqrt(p[0]**2 + p[1]**2))
这样写的可读性非常差，如下:可命名元组来解决
import collections
Point = collections.namedtuple(‘point‘,[‘x‘,‘y‘]) #相当创造了一个类，这个类的对象没有方法只有属性
p = Point(1,2) #实例化
from math import sqrt
sqrt(p.x**2 + p.y**2)
例：
point=collections.namedtuple(‘point‘,[‘x‘,‘y‘]) #相当创造了一个类，这个类的对象没有方法只有属性
p = point(1,2) #实例化
print(p)
print(p.x)
print(p.y)
缺点：是不能修改的
定义：队列
l 队列：先进来的先出去-——售票
l 栈：先进来的后出去——计算机的算法
区别：在存储数据的基础上，严格的维持了一个秩序
例1）：队列
import queue
q = queue.Queue()
l = list()
q.put(1)
q.put(2)
print(q.get())
输出：
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
1
例2）：双端队列：
解释：维持一个左侧右侧取放的规则
import collections
dq = collections.deque()
dq.append(1)
dq.append(2)
print(dq)
print(dq.pop())
输出：
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
deque([1, 2])
2
例3）：双端队列
import collections
dq = collections.deque()
dq.append(1)
dq.append(2)
print(dq)
print(dq.pop())
print(dq)
dq.appendleft(5)
print(dq.popleft())
print(dq)
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
deque([1, 2])
2
deque([1])
5
deque([1])
l 规范创建字典
d = dict([(‘a‘,1),(‘b‘,2),(‘c‘,3)])
print(d)
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
{‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
l 有序取值
from collections import OrderedDict
from collections import OrderedDict
d = OrderedDict([(‘a‘,1),(‘b‘,2),(‘c‘,3)])
print(d)
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
OrderedDict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])
注意：OrderedDict的key会按照插入的顺序排列，不是key本身排序
解释：不管key 在不在都不影响value
例1）：
from collections import defaultdict
dd = defaultdict(list)
print(dd)
dd[‘‘].append(1)
dd[‘skfdsjfk‘].append(2)
print(dd)
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
defaultdict(<class ‘list‘>, {})
defaultdict(<class ‘list‘>, {‘‘: [1], ‘skfdsjfk‘: [2]})
l list 为一个callable可调用对象
例：
from collections import defaultdict
def func():return 5
dd = defaultdict(5)
print(dd[‘dafdfsdfsadf‘])
print(dd)
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
Traceback (most recent call last):
File "D:/python/untitled2/python_8/lession.py", line 56, in <module>
dd = defaultdict(5)
TypeError: first argument must be callable or None
正确的
from collections import defaultdict
def func():return 5
dd = defaultdict(lambda : 5)
print(dd[‘dafdfsdfsadf‘])
print(dd)
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
5
defaultdict(<function <lambda> at 0x00000000027E9BF8>, {‘dafdfsdfsadf‘: 5})
l 默认值可以修改
例：
from collections import defaultdict
def func():return 5
dd = defaultdict(lambda : 5)
print(dd[‘dafdfsdfsadf‘])
print(dd)
dd[‘dafdfsdfsadf‘] = 20
print(dd)
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
5
defaultdict(<function <lambda> at 0x0000000001E29BF8>, {‘dafdfsdfsadf‘: 5})
defaultdict(<function <lambda> at 0x0000000001E29BF8>, {‘dafdfsdfsadf‘: 20})
l 默认字典练习题
有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {‘k1‘: 大于66 , ‘k2‘: 小于66}
方法1）
values = [11, 22, 33,44,55,66,77,88,99,90]
my_dict = {}
for value in values:
if value>66:
if ‘k1‘ in my_dict:
my_dict[‘k1‘].append(value)
else:
my_dict[‘k1‘] = [value]
else:
if ‘k2‘ in my_dict:
my_dict[‘k2‘].append(value)
else:
my_dict[‘k2‘] = [value]
print(my_dict)
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
{‘k2‘: [11, 22, 33, 44, 55, 66], ‘k1‘: [77, 88, 99, 90]}
方法2）
from collections import defaultdict
values = [11, 22, 33,44,55,66,77,88,99,90]
my_dict = defaultdict(lambda : ‘N/A‘)
my_dict = defaultdict(list)
for value in values:
if value > 66:
my_dict[‘k1‘].append(value)
else:
my_dict[‘k2‘].append(value)
print(my_dict)
输出：
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
defaultdict(<class ‘list‘>, {‘k2‘: [11, 22, 33, 44, 55, 66], ‘k1‘: [77, 88, 99, 90]
使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：
>>> from collections import defaultdict
>>> dd = defaultdict(lambda: ‘N/A‘)
>>> dd[‘key1‘] = ‘abc‘
>>> dd[‘key1‘] # key1存在
‘abc‘
>>> dd[‘key2‘] # key2不存在，返回默认值
‘N/A‘
引用方法
import time
time.time
time.sleep(1) #让你当前的程序阻塞一秒
为什么要用时间戳——计算机用的
import time
print(time.time())
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
1530523030.2910078 #linux时间戳时间
解释：人类时间
import time
print(time.strftime(‘%Y-%m-%d %H:%M:%S‘))
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
2018-07-02 17:20:46
python中时间日期格式化符号：
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
解释：struct_time元组共有9个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）
|
索引（Index） |
属性（Attribute） |
值（Values） |
|
0 |
tm_year（年） |
比如2011 |
|
1 |
tm_mon（月） |
1 - 12 |
|
2 |
tm_mday（日） |
1 - 31 |
|
3 |
tm_hour（时） |
0 - 23 |
|
4 |
tm_min（分） |
0 - 59 |
|
5 |
tm_sec（秒） |
0 - 60 |
|
6 |
tm_wday（weekday） |
0 - 6（0表示周一） |
|
7 |
tm_yday（一年中的第几天） |
1 - 366 |
|
8 |
tm_isdst（是否是夏令时） |
默认为0 |
例：
time.localtime()
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,
tm_hour=13, tm_min=59, tm_sec=37,
tm_wday=0, tm_yday=205, tm_isdst=0)
小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的
|
struct_time 元组时间 |
|
Time stamp 时间戳 |
|
Format string 格式化时间 |
|
strftime |
|
strptime |
|
localtime gmtime
|
|
mktime |
l 时间戳-->结构化时间
#time.gmtime(时间戳) #UTC时间，与英国伦敦当地时间一致
#time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法：与UTC时间相差8小时，UTC时间+8小时 = 北京时间
>>>time.gmtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
>>>time.localtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
l 结构化时间-->时间戳
#time.mktime(结构化时间)
>>>time_tuple = time.localtime(1500000000)
>>>time.mktime(time_tuple)
1500000000.0
l 结构化时间-->字符串时间
#time.strftime("格式定义","结构化时间") 结构化时间参数若不传，则现实当前时间
>>>time.strftime("%Y-%m-%d %X")
‘2017-07-24 14:55:36‘
>>>time.strftime("%Y-%m-%d",time.localtime(1500000000))
‘2017-07-14‘
l 字符串时间-->结构化时间
#time.strptime(时间字符串,字符串对应格式)
>>>time.strptime("2017-03-16","%Y-%m-%d")
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
>>>time.strptime("07/24/2017","%m/%d/%Y")
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)
l 结构化时间 --> %a %b %d %H:%M:%S %Y串
#time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串
>>>time.asctime(time.localtime(1500000000))
‘Fri Jul 14 10:40:00 2017‘
>>>time.asctime()
‘Mon Jul 24 15:18:33 2017‘
l 时间戳 --> %a %d %d %H:%M:%S %Y串
#time.ctime(时间戳) 如果不传参数，直接返回当前时间的格式化串
>>>time.ctime()
‘Mon Jul 24 15:19:07 2017‘
>>>time.ctime(1500000000)
‘Fri Jul 14 10:40:00 2017‘
例）计算时间差
import time
true_time=time.mktime(time.strptime(‘2017-09-11 08:30:00‘,‘%Y-%m-%d %H:%M:%S‘))
time_now=time.mktime(time.strptime(‘2017-09-12 11:00:00‘,‘%Y-%m-%d %H:%M:%S‘))
dif_time=time_now-true_time
struct_time=time.gmtime(dif_time)
print(‘过去了%d年%d月%d天%d小时%d分钟%d秒‘%(struct_time.tm_year-1970,struct_time.tm_mon-1,
struct_time.tm_mday-1,struct_time.tm_hour,
struct_time.tm_min,struct_time.tm_sec))
定义：随机
l 大于零且小于1的小数
import random
print(random.random())
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
0.6933507043242297
l 大于1且小于3的小数
import random
print(random.uniform(1,3))
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
1.3289565836680464
l 大于等于1且小于等于5之间的整数
import random
print(random.randint(1,5))
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
2
l 大于等于1且小于10之间的奇数
import random
print(random.randrange(1,10,2))
l 随机选择一个返回值
import random
print(random.choice([1,‘23‘,[4,5]]))
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
[4, 5]
列表中任意两个组合
import random
print(random.sample([1,‘23‘,[4,5]],2))
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
[[4, 5], 1]
import random
l 打乱次序
item=[1,3,5,7,9]
random.shuffle(item)
print(item)
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
[7, 3, 9, 1, 5]
从数字大小写子母中随机选取
import random
def random_code(num,alpha=True):
import random
code = ‘‘
for i in range(num):
choice = str(random.randint(0,9))
if alpha:
alpha_lower = chr(random.randint(65,90))
alpha_upper = chr(random.randint(97,122))
choice = random.choice([choice,alpha_lower,alpha_upper])
code += choice
return code
print(random_code(4,True))
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
b49b
例：
import random
import sys
def calRandomValue(total, num):
total = float(total)
num = int(num)
min = 0.01 # 基数
if (num < 1):
return
if num == 1:
print("第%d个人拿到红包数为：%.2f" % (num, total))
return
i = 1
while (i < num):
max = total - min * (num - i)
k = int((num - i) / 2)
if num - i <= 2:
k = num - i
max = max / k
monney = random.randint(int(min * 100), int(max * 100))
monney = float(monney) / 100
total = total - monney
print("第%d个人拿到红包数为：%.2f, 余额为: %.2f" % (i, monney, total))
i += 1
print("第%d个人拿到红包数为：%.2f, 余额为: %.2f" % (i, total, 0.0))
if __name__ == "__main__":
total = input(‘输入红包总金额:‘)
num = input(‘输入发红包数量:‘)
calRandomValue(total, num)
解释:和python解释器相关的模块
import sys
l sys模块是与python解释器交互的一个接口
sys.argv 命令行参数list,第一个元素是程序本身的路径
sys.exit(n) 退出程序，正常退出时exit(0),错误退出sys.exit(1)
sys.version 获取python解释程序的版本信息
sys.path 返回模块的搜索路径，初始化使用pythonpath环境变量的值
sys.platform 返回操作系统平台名称
解释：关系到你的模块是否顺利的被导入，每个代码都要用，
模块能不能顺利被导入，取决于你的模块是不是在sys.path路径中
路径的寻找是依据sys.path列表中的顺序查找的
找到一个符合的条件会停止查找
定义：判断是否为windows平台
判断python版本
import sys
print(sys.version)
print(sys.platform)
# print(sys.modules)
sys.exit()
输出
D:/python/untitled2/python_8/lession.py
3.6.2 (v3.6.2:5fd33b5, Jul 8 2017, 04:57:36) [MSC v.1900 64 bit (AMD64)]
win32
记载我们已经导入的模块名及导入的模块内存地址
import sys
print(sys.modules)
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
{‘builtins‘: <module ‘builtins‘ (built-in)>, ‘sys‘: <module ‘sys‘ (built-in)>, ‘_frozen_importlib‘: <module ‘_frozen_importlib‘ (frozen)>, ‘_imp‘: <module ‘_imp‘ (built-in)>, ‘_warnings‘: <module ‘_warnings‘ (built-in)>, ‘_thread‘: <module ‘_thread‘ (built-in)>, ‘_weakref‘
解释：退出
解释：效率高 直接写入文件，可以节省代码执行时间减少阻塞
import sys
sys.argv
print(sys.srgv)
if sys.srgv[1] == ‘wang‘ and sys.argv[1] == ‘wang123‘:
print("登录成功")
else:
user = input(‘username:‘)
pwd = input(‘pasword: ‘)
if user == ‘wang‘and pwd == ‘wang123
print(‘登录成功’)‘
终端操作：
解释：与操作系统相关的模块
os.walk 返回一个三元组（root，dirs,files）
root指当前正在遍历的这个文件夹的本身的地址
dirs是一个list，内容是该文件夹中所有的目录的名字（不包括子目录）
files同样是list，内容是该文件中所有的文件（不包括子目录）
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd
os.curdir 返回当前目录: (‘.‘)
os.pardir 获取当前目录的父目录字符串名：(‘..‘)
os.makedirs(‘dirname1/dirname2‘) 可生成多层递归目录
os.removedirs(‘dirname1‘) 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir(‘dirname‘) 生成单级目录；相当于shell中mkdir dirname
os.rmdir(‘dirname‘) 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir(‘dirname‘) 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove() 删除一个文件
os.rename("oldname","newname") 重命名文件/目录
os.stat(‘path/filename‘) 获取文件/目录信息
os.sep 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name 输出字符串指示当前使用平台。win->‘nt‘; Linux->‘posix‘
os.system("bash command") 运行shell命令，直接显示
os.popen("bash command).read() 运行shell命令，获取执行结果
os.environ 获取系统环境变量
os.path
os.path.abspath(path) 返回path规范化的绝对路径 os.path.split(path) 将path分割成目录和文件名二元组返回 os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素 os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。
即os.path.split(path)的第二个元素
os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path) 如果path是绝对路径，返回True
os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path) 返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小
所谓工作目录并不是当前文件所在的位置，而是当前python脚本的工作路径
显示当前文件所在的绝对路径
print(__file__)
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
D:/python/untitled2/python_8/lession.py
解释：相当于shell下的cd
例：
import os
print(__file__)#显示当前文件绝对路径
os.chdir(os.path.dirname(__file__))#切换到当前文件下，相当于先cd到文件目录
print(os.getcwd())#返回path的目录
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
D:/python/untitled2/python_8/lession.py
D:\python\untitled2\python_8
注意：os.stat(‘path/filename‘) 获取文件/目录信息 的结构说明
st_mode: inode 保护模式
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。
解释：返回path的大小有可能1024
例：输出字符串只是当前使用的平台
print(os.path.getsize(r‘D:\python\untitled2\python_8\lession.py‘))
print(os.path.getsize(r‘D:\python\untitled2\python_借鉴\员工信息练习.py‘))
print(os.path.getsize(r‘D:\python\untitled2\lianxi\1.py‘))
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
3989
12861
1388
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import os
f_dir = os.path.abspath(os.path.dirname(__file__))
def get_dir_size(dir):
size = 0
for root, dirs, files in os.walk(dir):
size += sum([os.path.getsize(os.path.join(root, name)) for name in files])
return size
if __name__ == ‘__main__‘:
size = get_dir_size(‘../‘)
print(‘Total size is: %.3f Mb‘ % (size / 1024 / 1024))
正则表达式和python语言，是一个独立的语法
l 字符串的匹配
l 从一个巨大的字符串集合中
l 根据规则来找到想要的内容
l 或者判断是否符合你的规定
l 解释：
字符组 ： [字符组]
在同一个位置可能出现的各种字符组成了一个字符组，在正则表达式中用[]表示
字符分为很多类，比如数字、字母、标点等等。
假如你现在要求一个位置"只能出现一个数字",那么这个位置上的字符只能是0、1、2...9这10个数之一。
l 常用范围
数字：[0-9]
字母：[A-Za-z]
|
正则 |
待匹配字符 |
匹配 |
说明 |
|
[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，用来验证十六进制字符 |
|
元字符 |
匹配内容 |
|
. |
匹配除换行符以外的任意字符 |
|
\w |
匹配字母或数字或下划线 |
|
\s |
匹配任意的空白符 |
|
\d |
匹配数字 |
|
\n |
匹配一个换行符 |
|
\t |
匹配一个制表符 |
|
\b |
匹配一个边界符 |
|
^ |
匹配字符串的开始 |
|
$ |
匹配字符串的结尾 |
|
\W |
匹配非字母或数字或下划线 |
|
\D |
匹配非数字 |
|
\S |
匹配非空白符 |
|
a|b |
匹配字符a或字符b |
|
() |
匹配括号内的表达式，也表示一个组 |
|
[...] |
匹配字符组中的字符 |
|
[^...] |
匹配除了字符组中字符的所有字符 |
|
量词 |
用法说明 |
|
* |
重复零次或更多次 |
|
+ |
重复一次或更多次 |
|
? |
重复零次或一次 |
|
{n} |
重复n次 |
|
{n,} |
重复n次或更多次 |
|
{n,m} |
重复n到m次 |
|
正则 |
待匹配字符 |
匹配 |
说明 |
|
海. |
海燕海娇海东 |
海燕海娇海东 |
匹配所有"海."的字符 |
|
^海. |
海燕海娇海东 |
海燕 |
只从开头匹配"海." |
|
海.$ |
海燕海娇海东 |
海东 |
只匹配结尾的"海.$" |
|
正则 |
待匹配字符 |
匹配 |
说明 |
|
李.? |
李杰和李莲英和李二棍子 |
李杰 |
?表示重复零次或一次，即只匹配"李"后面一个任意字符
|
|
李.* |
李杰和李莲英和李二棍子 |
李杰和李莲英和李二棍子 |
*表示重复零次或多次，即匹配"李"后面0或多个任意字符 |
|
李.+ |
李杰和李莲英和李二棍子 |
李杰和李莲英和李二棍子 |
+表示重复一次或多次，即只匹配"李"后面1个或多个任意字符 |
|
李.{1,2} |
李杰和李莲英和李二棍子 |
李杰和 |
{1,2}匹配1到2次任意字符 |
注意：前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配
|
正则 |
待匹配字符 |
匹配 |
说明 |
|
李.*? |
李杰和李莲英和李二棍子 |
李 |
惰 |
|
正则 |
待匹配字符 |
匹配 |
说明 |
|
李[杰莲英二棍子]* |
李杰和李莲英和李二棍子 |
李杰 |
表示匹配"李"字后面[杰莲英二棍子]的字符任意次
|
|
李[^和]* |
李杰和李莲英和李二棍子 |
李杰 |
表示匹配一个不是"和"的字符任意次 |
|
[\d] |
456bdha3 |
4 |
表示匹配任意一个数字，匹配到4个结果 |
|
[\d]+ |
456bdha3 |
456 |
表示匹配任意个数字，匹配到2个结果 |
身份证号码是一个长度为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 |
现在不会匹配错误的身份证号了 |
|
^([1-9]\d{16}[0-9x]|[1-9]\d{14})$ |
110105199812067023 |
110105199812067023 |
表示先匹配[1-9]\d{16}[0-9x]如果没有匹配上就匹配[1-9]\d{14} |
在正则表达式中，有很多有特殊意义的是元字符，比如\d和\s等，如果要在正则中匹配正常的"\d"而不是"数字"就需要对"\"进行转义，变成‘\\‘。
在python中，无论是正则表达式，还是待匹配的内容，都是以字符串的形式出现的，在字符串中\也有特殊的含义，本身还需要转义。所以如果匹配一次"\d",字符串中要写成‘\\d‘，那么正则里就要写成"\\\\d",这样就太麻烦了。这个时候我们就用到了r‘\d‘这个概念，此时的正则是r‘\\d‘就可以了。
|
正则 |
待匹配字符 |
匹配 |
说明 |
|
\d |
\d |
False |
因为在正则表达式中\是有特殊意义的字符，所以要匹配\d本身，用表达式\d无法匹配 |
|
\\d |
\d |
True |
转义\之后变成\\，即可匹配 |
|
"\\\\d" |
‘\\d‘ |
True |
如果在python中，字符串中的‘\‘也需要转义，所以每一个字符串‘\‘又需要转义一次 |
|
r‘\\d‘ |
r‘\d‘ |
True |
在字符串之前加r，让整个字符串不转义 |
贪婪匹配：在满足匹配时，匹配尽可能长的字符串，默认情况下，采用贪婪匹配
|
正则 |
待匹配字符 |
匹配 |
说明 |
|
<.*> |
<script>...<script> |
<script>...<script> |
默认为贪婪匹配模式，会匹配尽量长的字符串 |
|
<.*?> |
r‘\d‘ |
<script> |
加上？为将贪婪匹配模式转为非贪婪匹配模式，会匹配尽量短的字符串 |
*? 重复任意次，但尽可能少重复
解释： 重复1次或更多次，但尽可能少重复
?? 重复0次或1次，但尽可能少重复
{n,m}? 重复n到m次，但尽可能少重复
{n,}? 重复n次以上，但尽可能少重复
. 是任意字符
* 是取 0 至 无限长度
? 是非贪婪模式。
何在一起就是 取尽量少的任意字符，一般不会这么单独写，他大多用在：
.*?x
就是取前面任意长度的字符，直到一个x出现
import re
ret = re.findall(‘a‘, ‘eva egon yuan‘) # 返回所有满足匹配条件的结果,放在列表里
print(ret) #结果 : [‘a‘, ‘a‘]
ret = re.search(‘a‘, ‘eva egon yuan‘).group()
print(ret) #结果 : ‘a‘
# 函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
# 通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。
ret = re.match(‘a‘, ‘abc‘).group() # 同search,不过尽在字符串开始处进行匹配
print(ret)
#结果 : ‘a‘
ret = re.split(‘[ab]‘, ‘abcd‘) # 先按‘a‘分割得到‘‘和‘bcd‘,在对‘‘和‘bcd‘分别按‘b‘分割
print(ret) # [‘‘, ‘‘, ‘cd‘]
ret = re.sub(‘\d‘, ‘H‘, ‘eva3egon4yuan4‘, 1)#将数字替换成‘H‘，参数1表示只替换1个
print(ret) #evaHegon4yuan4
ret = re.subn(‘\d‘, ‘H‘, ‘eva3egon4yuan4‘)#将数字替换成‘H‘，返回元组(替换的结果,替换了多少次)
print(ret)
obj = re.compile(‘\d{3}‘) #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字
ret = obj.search(‘abc123eeee‘) #正则表达式对象调用search，参数为待匹配的字符串
print(ret.group()) #结果 ： 123
import re
ret = re.finditer(‘\d‘, ‘ds3sy4784a‘) #finditer返回一个存放匹配结果的迭代器
print(ret) # <callable_iterator object at 0x10195f940>
print(next(ret).group()) #查看第一个结果
print(next(ret).group()) #查看第二个结果
print([i.group() for i in ret]) #查看剩余的左右结果
\d+\.?|d*
原字符：12.12
12
匹配结果：
12.12
12
匹配规则：\d*?
import re
ret = re.findall(‘\d‘,‘eva6543 wang 656li‘)
print(ret)
ret1 = re.search(‘a‘,‘eva wang li‘).group()
print(ret1)
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
[‘6‘, ‘5‘, ‘4‘, ‘3‘, ‘6‘, ‘5‘, ‘6‘]
a
ret1 = re.search(‘\d‘,‘eva123 wang345 li128‘)
print(ret1)
print(ret1.group())
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
<_sre.SRE_Match object; span=(3, 4), match=‘1‘>
1
import re
#findall 特性 匹配的时候按照规则匹配，显示只显示分组内的
ret = re.findall(‘(\d)5‘,‘eva23454 wang 35li15‘)
print(ret)
ret = re.findall(‘\d5‘,‘eva23454 wang 35li15‘)
print(ret)
输出
D:/python/untitled2/python_8/lession.py
[‘4‘, ‘3‘, ‘1‘]
[‘45‘, ‘35‘, ‘15‘]
?的用法
import re
#在分组的开始加上？: 表示取消分组优先
ret = re.findall(‘(?:\d)5‘,‘eva23454 wang 35li15‘)
print(ret)
ret = re.findall(‘\d5‘,‘eva23454 wang 35li15‘)
print(ret)
输出
D:/python/untitled2/python_8/lession.py
[‘45‘, ‘35‘, ‘15‘]
[‘45‘, ‘35‘, ‘15‘]
#在search中没有正则规则的分组优先功能
ret = re.search(‘(\d)5‘,‘eva23454 wang 35li15‘)
print(ret.group())
输出
C:\python3\python.exe D:/python/untitled2/python_8/lession.py
45
l ？做量词 表示是0次或1次
l ？在量词后 表示惰性匹配
l ？:在分组开头 表示取消分组优先
例：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
for i in range(0,101,2):
time.sleep(0.1)
char_unm = i//2 #取整除，返回商的整数部分
# print(char_unm)
#\r表示不进行转义 %取模取出余数
per_str = ‘\r%s%%: %s\n‘ % (i,‘*‘ * char_unm) if i == 100 else ‘\r%s%% : %s‘%(i ,‘*‘* char_unm)
print(per_str,end=‘‘,flush=True)
标签：最新 sdi function 划线 等等 好的 结构 aci hat
原文地址：https://www.cnblogs.com/wang-xd/p/9269728.html
