python之模块

python之模块

 

一、模块的介绍：

1、模块的定义（一个py文件就是一个模块）

Python 模块(Module)，是一个Python文件，以.py 结尾，包含了

Python 对象定义和Python语句。

模块让你能够有逻辑地组织你的Python代码段。

把相关的代码分配到一个模块里能让你的代码更好用，更易懂。

模块能定义函数，类和变量，模块里也能包含可执行的代码。

 

二、模块的导入 

第一种':

import   模块名称

模块名称.函数

案例：
import   time
print("请开门")
time.sleep(5)
print("我进来了")

 

第二种：

from  模块 名称    import      * （所有）

函数

from  time import  *     * 号表示  所有函数
print(" 请开门")
sleep(5)
print("请进")

 

第三种：

from  模块 名称    import       sleep（所有）

from  time import  sleep
print(" 请开门")
sleep(5)
print("请进")

 

第四种:

from   模块名称   import     函数   as 别名

别名（）

print(" 请开门")
s(5)
print("请进")

 

第五种：导入其他模块

ss  模块

cc模块

cc文件：

from hz_bao import ss
ss.a()
ss.b()
ss.c()

 

ss文件：

def  a():
    print("杭州")
def  b():
    print("上海")
def  c():
    print("深圳")

 

==============================

Python中常见的模块：

time模块  

random模块

hashlib模块

os模块

re模块

string模块（拓展）

xlrd模块

json模块（拓展）

sys模块 （拓展）

==================================

python中time模块

time模块中常见的方法：

time() #1970到现在的经过的秒数

案例：

方法一：
import  time
print(time.time())  结果：1630911559.4688041

 

方法二：
from  time  import  *
print(time())  #结果：1630911628.3837867

 

ctime() #固定格式的当前时间

案例1
from  time  import  *
print(ctime())    #结果：Mon Sep  6 15:01:12 2021

 

sleep(3) #休眠 单位是秒

案例：

from  time  import  *
print(" 请进")
sleep(5)
print("我开门了")

 

asctime() #转换为asc码显示当前时间

from  time  import  *
print(asctime())
结果：Mon Sep  6 15:03:18 2021

strftime() #时间格式化  （重点）

from  time  import  *
print(strftime("%H-%M-%S--%y-%m-%d"))

 

==================================

python中random模块

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

random模块中常见的方法：

random.random() #该方法是生成0-1之间的浮点数，但是能取到0，但是取不到1

案例：

from  random import   *
print(random()) #结果0.6552172580859921

 

random.randint(x,y) #该方法生成指定范围内整数，包括开始和结束值random.randrange(x,y,step) #生成指定范围内的奇数，不包括结束值

备注：在radint  包含开始值和结束值，随机选取一位数  
from  random import   *
print(randint(1,10)) #结果1-10

 

random.randrange(x,y,step) #生成指定范围内的偶数，不包括结束值

案例1·：
print(randrange(1,101))  随机生成1-100之间的一位数

.

案例2：
from  random import   *
print(randrange(1,101,2)) 随机生成1-100之间的奇数的一位数 

 

案例3：
from  random import   *
print(randrange(0,101,2))

 

random.sample(seq,n) #从序列seq中选择n个随机且独立的元素

案例：

from  random import   *
a=[1,2,3,4,5,6,7,8,9,10]
print(sample(a,3))

 

 

random.choice(test) #生成随机字符

案例
from  random import   *
a=[1,2,3,4,5,6,7,8,9,10]
print(choice(a))

 

random.shuffle(list) #洗牌（随机数列）

案例：
from  random import   *
a=[1,2,3,4,7,6,7,8,9,10]
shuffle(a)
print(a)

 

==================================

string 模块

import  string
print(string.digits) #0123456789    生成0-9 数字
print(string.hexdigits) #0123456789abcdefABCDEF  #0-1，a-f大小写
print(string.ascii_uppercase) #ABCDEFGHIJKLMNOPQRSTUVWXYZ   #生成26个大写字母
print(string.ascii_lowercase) #abcdefghijklmnopqrstuvwxyz #生成26个小写字母

==========================================================================================================

 

练习：

1、使用random模块随机生成手机号码、自己定义手机号码开头的前三位

2、用random模块随机生成6位数验证码

3、通过md5加密算法把随机生成的6位数验证码进行加密返回16进制的字符串

 

第一题：

方法一：

a=[0,1,2,3,4,5,6,7,8,9]
b=[183]#自定义前三位
c=sample(a,8)#随机生成后八位
for i in (b+c):
    print(i,end='')

 

方法二：（后面八位不重复，都是洗牌中的内容）

from random import *
a=[1,2,3,4,5,6,7,8,9]
b=[1,3,6]
shuffle(a)
b.extend(a)
print(b[0:11])

 

方法三：（有缺陷）

import random
r = random.randint(10000000, 99999999)
phone = '155' + str(r)
print(phone)

 

方法四：

a=[0,1,2,3,4,5,6,7,8,9]
b=[1,3,7]
print(type(len(b)))
while len(b) != 11:
b.append(random.choice(a))
print(b)

方法五：

from random import *
b=[1,7,6]
i=1
while i<=8:
    b.append(randint(0,9))
    i = i + 1
c = map(str, b)
print("".join(c))

 

方法六：

import random
def phone():
    s=random.choice([3,4,5,7,8,9])
    t={
        3:random.randint(0,9),
        4:random.choice([5,7,9]),
        5:random.choice([0,1,2,3,4,5,7,8]),
        7:random.choice([2,3,5,6,7,8]),
        8:random.randint(0,9),
        9:random.choice([1,3,8,9]),
    }[s]
    suffix=random.randint(9999999,100000000)
    return "1{}{}{}".format(s,t,suffix)
for i in range(100):
    randomphone=phone()
    print(randomphone)

 

 

第二题：

方法一：

from   random  import  *
a=[0,1,2,3,4,5,6,7,8,9]
c=[]
while len(c)!=6:
    c.append(choice(a))
print(c)

 

方法二：（不足之处 001000）

import random
ran = random.randint(100000, 999999)
# ran = random.randrange(100000, 1000000)
print(ran)

 

方法三：（备注无重复）

from   random import   *
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
c = sample(a, 6)  # 随机生成6为数验证码
for i in (c):
    print(i, end='')

 

方法四：

import   random
import  string
num=string.ascii_lowercase+string.ascii_uppercase+string.digits
a=random.sample(num,6)
print("".join(a))

 

方法五：

import   random
import  string
c=[]
num=string.ascii_lowercase+string.ascii_uppercase+string.digits
for i  in  range(6):
       a=random.choice(num)
       c.append(a)
print("".join(c))

方法六：

 import random,string
 b=[]
 str=string.digits
 for i in range(6):
     s="".join(random.sample(str,1))
     b.append(s)
 print("".join(b))

 

==================================

加密算法：

 

加密算法：
MD5 ，RSA，AES,DES,BASE
DES以64位为分组对数据加密,加密和解密用的是同一个算法.
RSA加密算法是一种非对称加密算法(在公开密钥加密和电子商业中RSA被广泛使用)
AES Rijndael加密法对称密钥加密中最流行的算法之一 (AES为分组密码)。
DES  算法为密码体制中的对称密码体制,（DES以64位为分组对数据加密,加密和解密用的是同一个算法.）
base64 编码

Base64编码
Base64编码是一种用64个字符来表示任意二进制数据的方法
base64是python内置的模块可以直接进行base64的编码和解码

 案例1：

#base64 加密
import  base64
a=base64.b64encode(b"123456")
print(a)  # b'MTIzNDU2'
#base64 解密
c=base64.b64decode(b'MTIzNDU2')
print(c)

 

MD5  加密 

 DM5加密

MD5 定义：md5,是一种算法.可以将一个字符串,或文件,或压缩包,执行md5后,就可以生成一个固定长度为128bit的字符串,这个串,基本上是唯一的

由因为MD5模块在python3中被移除,在python3中使用hashlib模块进行md5操作
Hash，译做“散列”，也有直接音译为“哈希”的。把任意长度的输入，通过某种hash算法，变换成固定长度的输出，该输出就是散列值，也称摘要值。该算法就是哈希函数，也称摘要函数。
MD5是最常见的摘要算法，速度很快，生成结果是固定的16字节，通常用一个32位的16进制字符串表示。
SHA1算法更安全点，它的结果是20字节长度，通常用一个40位的16进制字符串表示。
而比SHA1更安全的算法是SHA256和SHA512等等，不过越安全的算法越慢，并且摘要长度更长。

 在线加解密：
http://encode.chahuo.com/
 https://tool.oschina.net/encrypt?type=2

 

案例：
import  hashlib
m=hashlib.md5()  #创建一个对象：m
m.update(b"123456")  #通过m对象来调用update 方法对某个值进行加密处理
print(m.hexdigest()) #通过hexdigest 将MD5机密进行16进制的转换
#结果：e10adc3949ba59abbe56e057f20f883e

备注：MD5 不能反接，但是加密是固定，管子是意义对应，所以有缺陷，可以被对撞出来。

 

sha256：

import  hashlib
s=hashlib.new('sha256',b'123456')
print(s.hexdigest())
结果：8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92

 

sha512：

import  hashlib
s=hashlib.new('sha512',b'123456')
print(s.hexdigest())

 

ba3253876aed6bc22d4a6ff53d8406c6ad864195ed144ab5c87621b6c233b548baeae6956df346ec8c17f5ea10f35ee3cbc514797ed7ddd3145464e2a0bab413

 

=======================================================================================================

面试题：如当前有两个数都是几十万，上百万条数据，如何鉴别两数据是完成一样的？

通过加密发方式来处理，加密以后的编码都是一致，说明数据一样，如果加密编码不一致，则说明数据有问题。

 

 

面试题： 通过md5加密算法把随机生成的6位数验证码进行加密返回16进制的字符串？

方法一：

from random import *
from hashlib import *
str1 = '0123456789qwertyuiopasdfghjklzxcvbnm'
a = ''.join(sample(str1,6))
print('验证码为：',a)
m=md5()
m.update(a.encode('utf-8'))
print('验证码加密后为：',m.hexdigest())

方法二：

import random
import string
import hashlib
c=[]
num=string.ascii_lowercase+string.ascii_uppercase+string.digits
for i  in  range(6):
    a=random.choice(num)
    c.append(a)
print("".join(c))
m=hashlib.md5()
m.update(b"a")
print(m.hexdigest())

方法三

import  random,string,hashlib,base64
d=[]
a=string.hexdigits+string.ascii_letters
b=random.sample(a,6)
c="".join(b)
d=hashlib.md5(c.encode(encoding='utf-8'))
m=d.hexdigest()
prin：

方法四：

from random import *
from hashlib import *
str1 = '0123456789qwertyuiopasdfghjklzxcvbnm'
a = ''.join(sample(str1,6))
print('验证码为：',a)
m=md5()
m.update(a.encode('utf-8'))
print('验证码加密后为：',m.hexdigest())

 

==============================================================
os  模块

os 模块对于目录，文件路径常用的模块

os模块中常见的方法：

os.getcwd()获取当前执行命令所在目录

os.path.isfile()判断是否文件os.path.isdir() #判断是否是目录

os.path.exists() #判断文件或目录是否存在

os.listdir(dirname) #列出指定目录下的目录或文件

os.path.split(name) #分割文件名与目录

os.path.join(path,name) #连接目录与文件名或目录

os.mkdir(dir) #创建一个目录

os.rename(old,new) #更改目录名称

 

 

 

import    os
print(os.getcwd())   #获取当前操作文件对应的路径（相对路径）
#相对路径：C:\Users\Administrator\PycharmProjects\hz10\hz_bao
# 绝对路径：C:\Users\Administrator\PycharmProjects\hz10\hz_bao\hz_10_001.py


#print(os.path.isfile())  #判断当前是否文件，返回是布尔值：ture 或falsh
a=r"C:\Users\Administrator\PycharmProjects\hz10\hz_bao\hz_10_007模块.py" #.py文件
b=r"C:\Users\Administrator\PycharmProjects\hz10\hz_bao" #包
c=r"C:\Users\Administrator\PycharmProjects\hz10\hz_mu" #目录
d=r"D:\ls\data.txt" #txt文件
e="D:\ls\ls"  #目录
f="D:\ls\ls\data.xlsx"
print(os.path.isfile(a)) #True
print(os.path.isfile(b))  #False
print(os.path.isfile(c))  #False
print(os.path.isfile(d))  #True
print(os.path.isfile(e))  #False
print(os.path.isfile(f))  #True

 

import    os
#exists  判断文件是否存在
a=r"C:\Users\Administrator\PycharmProjects\hz10\hz_bao\hz_10_007模块.py" #.py文件
a1=r"C:\Users\Administrator\PycharmProjects\hz10\hz_bao\hz_10_008.py" #不存在的py文件
b=r"C:\Users\Administrator\PycharmProjects\hz10\hz_bao" #包
b1=r"C:\Users\Administrator\PycharmProjects\hz10\hz_baobao" #不存包
c=r"C:\Users\Administrator\PycharmProjects\hz10\hz_mu" #目录
c1=r"C:\Users\Administrator\PycharmProjects\hz10\hz_mulu" #不存在目录
d=r"D:\ls\data.txt" #txt文件
d1=r"D:\ls\bucunzdata.txt" #不存在txt文件
e="D:\ls\ls"  #目录
e1="D:\ls\lslsls"  #不存在目录
# print(os.path.exists(a))  #True
# print(os.path.exists(a1)) #False
# print(os.path.exists(b))  # True
# print(os.path.exists(b1))  #False
# print(os.path.exists(c))  #True
# print(os.path.exists(c1)) #False
print(os.path.exists(d))  #True
print(os.path.exists(d1)) #False
print(os.path.exists(e))  #True
print(os.path.exists(e1)) #False

 

判断目录是否存在，不存在则创建
import   os
d1=r"D:\ls\fx\hz10_data.txt" #不存在txt文件
if not os.path.exists(d1):
    os.mkdir(d1)

 

判断文件是否存在，不存在则创建，创建后在追加或覆盖
import   os
import  codecs   #模块codecs
d1=r"D:\ls\fx\bb.txt" #不存在txt文件
if not os.path.exists(d1):
    os.mkdir("bb.txt")
    with codecs.open(d1,"a",encoding='utf-8') as f:   
        f.write("aaaa")

 

import   os
a=r"C:\Users\Administrator\PycharmProjects\hz10\hz_bao\dd.py"
os.remove(a)  删除文件

 

使用remove 无法删除目录
import   os
a=r"C:\Users\Administrator\PycharmProjects\hz10\hz_bao"
os.remove(a)

 

os.path.isdir 判断是否目录

import    os
a=r"C:\Users\Administrator\PycharmProjects\hz10\hz_bao\hz_10_007模块.py" #.py文件
b=r"C:\Users\Administrator\PycharmProjects\hz10\hz_bao" #包
c=r"C:\Users\Administrator\PycharmProjects\hz10\hz_mu" #目录
print(os.path.isdir(a)) #False
print(os.path.isdir(b)) #True
print(os.path.isdir(c)) #True

 

listdir  获取当前路径下的所有的目录和文件
import    os
b=r"C:\Users\Administrator\PycharmProjects\hz10\hz_bao" #包
print(os.listdir(b))

 

os.path.split()   对某个路径进行分割，目录和文件

import    os
a=r"C:\Users\Administrator\PycharmProjects\hz10\hz_bao\hz_10_007模块.py"
#第一步：split 对路径进行分割
print(os.path.split(a))
#第二步：根据索引取路径的值
path=os.path.split(a)[0]
path1=os.path.split(a)[1]
print(path)
print(path1)
#第三步：拼接路径
pj=os.path.join(path,"zg.txt")
print(pj)  #C:\Users\Administrator\PycharmProjects\hz10\hz_bao\zg.txt

 

#abs 通过名称来获取当前名称对应的路径
import    os
a="hz_10_007模块.py"
print(os.path.abspath(a))
#C:\Users\Administrator\PycharmProjects\hz10\hz_bao\hz_10_007模块.py

 

mkdir 创建一个目录

import  os
a=d=r"D:\ls\fx\kk"
os.mkdir(a,755)  #  目录要设置权限， 777 或755

 

rename 修改文件名

import  os  
a=r"D:\ls\fx\kk"  #原文件名
b=r"D:\ls\fx\mm"  #新文件名
os.rename(a,b)

 

#固定格式
#获取当前操作对象中的项目路径的固定语法
path=os.path.abspath(os.path.dirname(__file__))
print(path)
# 结果：C:\Users\Administrator\PycharmProjects\hz10
#获取当前绝对路径，进行分割
file_path=os.path.split(os.path.realpath(__file__))
print(file_path)
print(file_path[1])
v=(file_path[0])
pj=os.path.join(v,"hz10")
print(pj)
#结果：C:\Users\Administrator\PycharmProjects\hz10\hz_bao\hz10

 

==========================

xlrd 模块

xlrd模块

1）xlrd是可用于读取excel表格数据(不支持写操作，写操作需要xlwt模块实现)
  2）支持 xlsx和xls 格式的excel表格(不支持csv文件，csv文件可用python自带的csv模块操作)
  3）模块安装方式：pip3 install xlrd
  4）模块导入方式： import xlrd

一、在dos中安装xlrd
pip install xlrd
pip3 install xlrd

pip  uninstall   xlrd  卸载xlrd
pip  install  xlrd ==1.2.0

========================================

dos中：

win+R  输入cmd 

=========================================

pycharm 中安装xlrd模块 1.2.0版本

二、导入模块：
import xlrd
三、打开文件：

（1）创建hz10.xlsx

 (2)data.xlsx中的函数open_workbook
data = xlrd.open_workbook("data.xlsx")
单元格中数据类型：
python获取单元格中数据类型后，打印出来对并不是数据类型，而是用不同对数字映射对应对数据类型；
数据类型和数字对映射关系如下：
（3）
 0 empty, # 
1 string（text）,  文本
 2 number,   号
 3 date,     时间
#4 boolean,   布尔值
 5 error，    错误
#6 blank(空白表格)

1、获取sheet：

获取所有sheet名字：data.sheet_names（）
获取sheet数量：data.sheets
获取所有sheet对象：data.sheets()
通过sheet名查找：data.sheet_by_name("test”)
通过索引查找：data.sheet_by_index(3
案例1：
import xlrd
data = xlrd.open_workbook("d:\\bao\\info.xlsx")   #打开excel文件
print (data.sheets()[0])       #通过索引顺序获取sheet对象
print (data.sheet_by_index(0))    #通过索引顺序获取sheet对象
print (data.sheet_by_name("Sheet1"))      #通过名称获取sheet对象
print (data.sheet_names())     #返回book中所有工作表的名字
!

备注：第一页是从0开始；

2、获取sheet的汇总数据：

获取sheet名：sheet.name
获取总行数：sheet.nrows
获取总列数：sheet.ncols
import xlrd
data = xlrd.open_workbook("d:\\bao\\info.xlsx")
sheet = data.sheets()[0]
print (sheet.name)     #表格的第一页sheet表名hz
print (sheet.nrows)    #行数10行
print (sheet.ncols)    #列数4列

 3、单元格批量读取：
    a）行操作：
sheet.row_values(0)  # 获取第一行所有内容，合并单元格，首行显示值，其它为空。

sheet.row(0)         　　# 获取单元格值类型和内容

sheet.row_types(0)   # 获取单元格数据类型

场景一：

import xlrd
data = xlrd.open_workbook("d:\\bao\\info.xlsx")
sheet = data.sheets()[0]
print (sheet.row_values(0))  
打印结果：['Host', 'User', 'PassWord', 'Port']
print (sheet.row(0))
打印结果：[text:'Host', text:'User', text:'PassWord', text:'Port']
print (sheet.row_types(0))
打印结果：array('B', [1, 1, 1, 1])

4、表操作

 

sheet.row_values(0, 6, 10)   # 取第1行，第6~10列（不含第10表）

sheet.col_values(0, 0, 5)    # 取第1列，第0~5行（不含第5行）

sheet.row_slice(2, 0, 2)     # 获取单元格值类型和内容

sheet.row_types(1, 0, 2)   # 获取单元格数据类型

import xlrd
data = xlrd.open_workbook("d:\\bao\\info.xlsx")
sheet = data.sheets()[0]
print (sheet.row_values(1,2,4))# 取第1行，第6~10列（不含第10行）
#备注行数从0开始算，第一个数表示行数，第二个数表示开始列，第三个数表示结束列

print (sheet.col_values(0,0,3))  # 取第1列，第0~5行（不含第5行）
#备注列数从0开始算，第一个数表示列数，第二个数表示开始行，第三个数表示结束行

print (sheet.row_slice(2,0,2))           # 获取单元格值类型和内容
#备注列数从0开始算，第一个数表示3行，第二个数表示开始列，第三个数表示结束列

5、特定单元格读取：
 a) 获取单元格值：
第一个数表示行数，第二个数表示列数（都是0开始算）
import xlrd
data = xlrd.open_workbook("d:\\bao\\info.xlsx")
sheet = data.sheets()[0]

print(sheet.cell_value(1, 2))  #打印结果：123.0
print(sheet.cell(1, 2).value)#打印结果：123.0
print(sheet.row(1)[2].value )#打印结果：123.0

b) 获取单元格类型：
import xlrd
data = xlrd.open_workbook("d:\\bao\\info.xlsx")
sheet = data.sheets()[0]
print(sheet.cell(1, 2).ctype)   #打印结果：2
print(sheet.cell_type(1, 2))#打印结果：2
print(sheet.row(1)[2].ctype)#打印结果：2
6、案例场景
data = xlrd.open_workbook("D:\\bao\\info.xlsx")
sheet = data.sheets()[0]
print (sheet.nrows)           #获取该sheet中的有效行数
print (sheet.row(0))          #返回由该行中所有的单元格对象组成的列表
print (sheet.row_slice(0))    #默认返回由该行中所有的单元格对象组成的列表
print (sheet.row_values(0,1)) #默认返回由该行中所有单元格的数据组成的列表
print (sheet.row_len(0))      #索引值为0的行中有效单元格有几个
7、获取 表格中第一列所有的数据（for  循环）
import xlrd
book = xlrd.open_workbook("d:\\bao\\info.xlsx")
sheet = book.sheets()[0]
#通过for循环遍历取出excel表中第一列所有的数据
for i in range(sheet.nrows):
    print (sheet.row_values(i)[0])

===============================

import  xlrd
path=r"D:\ls\hz10.xlsx"
data=xlrd.open_workbook(path)  #打开excel 表格
sheet=(data.sheets()[0])  #通过索引顺序获取sheet对象
print(sheet.row_values(0)) #第一行的所有内容['user', 'passwd', 'age', 'sex']
print(sheet.row(0))  #  获取单元格的类型和内容[text:'user', text:'passwd', text:'age', text:'sex']
print(sheet.row_values(1,2,4))
#1 表示行，行数索引从0开始计算，1表示第二行 ；
# 2表示开始列：从0开始计算，4表示结束列（不包含结束列）
print(sheet.row_values(4,3,5))
print(sheet.col_values(1,2,5))
#1表示第二列：索引从0开始，1表示第二列
#2表示第三行：索引从0开始，2表示第三行
#5表示第6行：索引从0开始，不包含结束行，只取第五行
#遍历列数
# for i  in  range(sheet.nrows):
#     print(sheet.row_values(i)[2])
#遍历行数
for i  in  range(sheet.ncols):
    print(sheet.col_values(i)[2])

 

===============================

re模块：

正则匹配：使用re模块实现
1、什么正则表达式？
正则表达式是一种对字符和特殊字符操作的一种逻辑公式，从特定的字符中，用正则表达字符串来过滤的逻辑。
基本介绍：

（1）正则表达式是一种文本模式；
（2）帮助我们检查字符是否与某种模式匹配
（3）re模块使python语言拥有全部的真正表达式功能，从python1.5版本起增加了re模块
2、正则表达式作用？
（1）快速高效的查找和分析字符串  比对字符，也叫模式匹配;具有查找，比对，匹配，替换，插入，添加，删除等能力
案例一：把一个字符中的所有数字匹配出来，\d  findall
案例二：编写爬虫收集数据，首先得到网页源码，（比如html），要提取有效数据（比如img字符），使用正则匹配出来；
（2）实现一个编译查找，一般在日志处理文件处理时用的多
3、认识我们正则表达式中特殊元素？

re模块数量词匹配：
 预定义字符集匹配： 
\d:数字0-9
 \D:非数字 
\s:空白字符 
\n:换行符

\w    匹配字母数字
\W    匹配非字母数字
^：表示的匹配字符以什么开头 
$：表示的匹配字符以什么结尾 
*：匹配*前面的字符0次或n次 eg：ab  （* 能匹配a 匹配ab 匹配abb ）
+：匹配+前面的字符1次或n次 
?：匹配?前面的字符0次或1次 
{m}：匹配前一个字符m次 
{m,n}：匹配前一个字符m到n次(包括n次)，m或n可以省略，mn都是 
#1、findall # 从第一个字符开始查找，找到全部相关匹配为止，找不到返回一个空列表[] # 
#2、match
#从第一个字符开始匹配，如果第一个字符不是要匹配的类型、则匹配失败得到一个none值
 注意：如果规则带了'+'，则匹配1次或者多次，无'+'只匹配一次
3、compile # 编译模式生成对象，找到全部相关匹配为止，找不到返回一个列表[]
 4、search
#从第一个字符开始查找、一找到就返回第一个字符串，找到就不往下找，找不到则报错

案例1：findall # 从第一个字符开始查找，找到全部相关匹配为止，找不到返回一个空列表[] #

findall 查找所有的字符
import   re
f="adminadminabcdef"
s=re.findall("a",f)
print(s)

 

案例2：查看不存在的字符，则返回空列表
import   re
f="adminadminabcdef"
s=re.findall("s",f)
print(s)

 

2、案例：match

从第一个字符开始匹配，如果第一个字符不是要匹配的类型、则匹配失败得到一个none值

案例1：

import   re
f="adminadminabcdef"
s=re.match("s",f)
print(s)  #不存在的数据则返回None

 

案例2：
import   re
f="adminadminabcdef"
s=re.match("a",f)
print(s) 结果：<re.Match object; span=(0, 1), match='a'>   对象

 

案例三
import   re
f="adminadminabcdef"
s=re.match("a",f)
print(s.span())  结果：(0, 1)

 

3、search 

#从第一个字符开始查找、一找到就返回第一个字符串，找到就不往下找，找不到则报错

案例1:
import   re
f="adminadminabcdef"
s=re.search("i",f)
print(s.span())

 

案例2：

import   re
f="adminadminabcdef"
s=re.search("s",f)
print(s)

不存在的字符则返回None

 

group       以str 形式返回对象中match的元素

start   返回开始位置

end   返回结束位置

span   以tuple 形式返回范围

 

=====================================================

场景一：\d  :数字0-9

import  re
a="123456abcdefg"
s=re.findall("\d",a)
print(s)
结果：['1', '2', '3', '4', '5', '6']

 

场景二： \D:非数字 

import  re
a="123456abcdefg"
s=re.findall("\D",a)
print(s)

 

场景三：\s 空白字符

import  re
a="123456 abcd efg"
s=re.findall("\s",a)
print(s) #[' ', ' ']

 

场景四：\n  换行符

import  re
a="1234\n56 ab\ncd efg"
s=re.findall("\n",a)
print(s)

 

=====================================================

场景一：符号^ 表示的匹配字符以什么开头

import  re
a="1234\n56 ab\ncd efg"
s=re.match("^1",a)
print(s)

 

 

场景二：符号$ 表示的匹配字符以什么结尾

import  re
a="123456abdefg"
s=re.search("g$",a)
print(s)

 

场景三：符号*   表示的匹配*前面字符0次或n次

import  re
a="123456abdeadfgabblllabbbbbb"
s=re.findall("ab*",a)
print(s)
结果：['ab', 'a', 'abb', 'abbbbbb']

 

场景四：符号+   表示的匹配+前面字符1次或n次

import  re
a="123456abdeadfgabblllabbbbbb"
s=re.findall("ab+",a)
print(s)   结果：['ab', 'abb', 'abbbbbb']

场景五：符号？   表示的匹配？前面字符0次或1次

import  re
a="123456abdeadfgabblllabbbbbb"
s=re.findall("ab?",a)
print(s)

 

场景六：{m}   表示的匹配前一个字符m次

import  re
a="123456abdeadfgabblllabbbbbb"
s=re.findall("ab{1}",a)
print(s) #['ab', 'ab', 'ab']

 

场景：七  符号{n,m}   表示的匹配前一个字符m到n次  （包括n次 ）

import  re
a="123456aaabdeadfgaabblllabbbbbbkabbbb"
s=re.findall("ab{1,4}",a)
print(s)  结果：['ab', 'abb', 'abbbb', 'abbbb']

 

=====================================================
sub替换

import  re
a="123456aaabdeadfgaabblllabbbbbbkabbbb"
s=re.sub("a"," 我在中国",a)
print(s)
结果：123456 我在中国 我在中国 我在中国bde 我在中国dfg 我在中国 我在中国

 

=====================================================

标志匹配符
 re.I    忽略大小写（常用）
 re.L    做本地化识别（locale-aware）匹配（少用）
re.M    多行匹配,能匹配到换行\n，影响 ^ 和 $
 re.S    使 . 匹配包括换行在内的所有字符
re.U    根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X    该标志通过给予更灵活的格式，以便将正则表达式写得更易于理解。
备注：(1)re.后面的字符都是大写

案例： re.I    忽略大小写（常用）

import  re
a="123456aaabdeadAAfgaabblllAAAbbAAAbbbbkabbbb"
s=re.findall("a",a,flags=re.I)
print(s)

 

案例：re.M    多行匹配,能匹配到换行\n，影响 ^ 和 $

import  re
a="123456aaabdeadAAfgsssaa\nblllA\nAAbbAAAbbb\nbkabbbbHHHHHHHSSSs"
print(a)
s=re.findall("s",a,flags=re.M)
print(s)