【笔记】python中常见的函数（一）

1、bisect是python中的内置函数

import bisect
# 这里listA表示数组，x表示插入的值，返回的是x插入listA中
# 的索引位置
bisect.bisect(listA, x)

2、glob是python自带的函数
用它可以查找符合特定规则的文件路径名。使用该模块查找文件，只需要用到： “*”, “?”, “[]”这三个匹配符：
” * ”匹配0个或多个字符；
” ? ”匹配单个字符；
” [] ”匹配指定范围内的字符，如：[0-9]匹配数字。

3、re是python中引入正则表达式

import re
#pattern 为要校验的规则
#str 为要进行校验的字符串
result = re.match(pattern, str) 
 
#如果result不为None,则group方法则对result进行数据提取
result.group()

# 单字符匹配规则
字符    功能
.       匹配任意1个字符(除了\n)
[]      匹配[]中列举的字符
\d      匹配数字,也就是0-9
\D      匹配非数字,也就是匹配不是数字的字符
\s      匹配空白符,也就是 空格\tab
\S      匹配非空白符,\s取反
\w      陪陪单词字符, a-z, A-Z, 0-9, _
\W      匹配非单词字符, \w取反

# 表示数量的规则
字符    功能
*       匹配前一个字符出现0次多次或者无限次,可有可无,可多可少
+       匹配前一个字符出现1次多次或则无限次,直到出现一次
?       匹配前一个字符出现1次或者0次,要么有1次,要么没有
{m}     匹配前一个字符出现m次
{m,}    匹配前一个字符至少出现m次
{m,n}   匹配前一个字符出现m到n次

# 例一：验证手机号是否符合规则
#首先清楚手机号的规则
#1.都是数字 2.长度为11 3.第一位是1 4.第二位是35678中的一位
 
pattern = "1[35678]\d{9}"
phoneStr = "18230092223"
 
result = re.match(pattern, phoneStr)
result.group()
 
# 表示边界
字符    功能
^       匹配字符串开头
$       匹配字符串结尾
\b      匹配一个单词的边界
\B      匹配非单词边界

# 例：边界(制定规则来匹配str="ho ve r")
import re
 
#定义规则匹配str="ho ve r"
#1. 以字母开始
#2. 中间有空字符
#3. ve两边分别限定匹配单词边界
 
pattern = r"^\w+\s\bve\b\sr"
str = "ho ve r"
result = re.match(pattern, str)
result.group()

# 匹配分组
字符        功能
|           匹配左右任意一个表达式
(ab)        将括号中字符作为一个分组
\num        引用分组num匹配到的字符串
(?P<name>)  分组起别名
(?P=name)   引用别名为name分组匹配到的字符串

# 例: 匹配出0-100之间的数字
import re
 
#匹配出0-100之间的数字
#首先:正则是从左往又开始匹配
#经过分析: 可以将0-100分为三部分
#1. 0        "0$"
#2. 100      "100$"
#3. 1-99     "[1-9]\d{0,1}$"
#所以整合如下
 
pattern = r"0$|100$|[1-9]\d{0,1}$"
#测试数据为0,3,27,100,123
result = re.match(pattern, "27")
result.group()
 
#将0考虑到1-99上,上述pattern还可以简写为:pattern=r"100$|[1-9]?\d{0,1}$"

# 例: 匹配分组,获取页面中的<h1>标签中的内容
import re
#匹配分组,获取页面<h1>标签中的内容, 爬虫的时候会用到
 
str = "<h1>hello world!<h1>"
pattern = r"<h1>(.*)</h1>"
result = re.match(pattern, str)
result.group()
 
# 例: 分组引用, 精确获取多个标签内的内容
import re
 
#引用分组,精确获取多个标签内的内容
#"\1"是对第一个分组的引用,同理......
 
str = "<span><h1>hello world!</h1></span>"
pattern = r"<(.+)><(.+)>.*</\2></\1>"
result = re.match(pattern, str)
result.groups()
 
# 例:分组起别名
import re
 
#分组起别名
 
str = "<span><h1>hello world!</h1></span>"
pattern = "<(?P<key1>.+)><(?P<key2>.+)>(?P<nr>.*)</(?P=key2)></(?P=key1)>"
result = re.match(pattern, str)
result.groups()
 
# search(全局搜索,只要有就返回,不再继续往下找),用法和match一样:
# 例一. search简单实例
import re
 
#search的用法
 
str = "<span><h1>hello world!</h1></span>"
pattern = r"hello"
result = re.search(pattern, str)
result.group()
 
#  例. search匹配字符串中的数字:
import re
 
#读取字符串中文章浏览次数
 
str = "浏览次数为: 8098"
pattern = r"\d+"
result = re.search(pattern, str)
result.group()
 
# findall获取所有匹配的查找
import re
 
#findall方法取得所有满足的查找
 
str = "itwang</h1>sdfhjkd</html>itli</h1>"
pattern = r"\w+</h1>"
result = re.findall(pattern, str)
print(result)
 
# sub 将匹配到的数据进行替换
import re
 
#sub将匹配到的数据进行替换
 
str = "python_score = 98"
pattern = "\d+"
result = re.sub(pattern, "100", str)
print(result)
 
#  例:与函数结合使用
import re
 
#与函数配合使用
 
str = "python=96, math=93"
pattern = "\d+"
def replace(result)
    pass
    return "99"
#被查出的[96,93]都会被当做参数分别在调用replace函数时当做参数被传进去,可自行修改replace函数测试.
result = re.sub(pattern, replace, str) 
print(result)
 
# python中""" """可以定义一个原生字符串(也就是说,不管该字符串有双引号单引号,都会保留,不用我们自己进行转义等特殊处理),例如下面一个字符串:
str="""
<div>
    <p>岗位职责： </p>
    <p>完成推荐算法、 数据统计、 接⼝、 后台等服务器端相关⼯作</p>
    <p><br></p>
    <p>必备要求： </p>
    <p>良好的⾃我驱动⼒和职业素养， ⼯作积极主动、 结果导向</p>
    <p>&nbsp;<br></p>
    <p>技术要求： </p>
    <p>1、 ⼀年以上 Python 开发经验， 掌握⾯向对象分析和设计， 了解设计模式</p>
    <p>2、 掌握HTTP协议， 熟悉MVC、 MVVM等概念以及相关WEB开发框架</p>
    <p>3、 掌握关系数据库开发设计， 掌握 SQL， 熟练使⽤ MySQL/PostgreSQL 中的⼀种<br></p>
    <p>4、 掌握NoSQL、 MQ， 熟练使⽤对应技术解决⽅案</p>
    re模块的⾼级⽤法33
    <p>5、 熟悉 Javascript/CSS/HTML5， JQuery、 React、 Vue.js</p>
    <p>&nbsp;<br></p>
    <p>加分项： </p>
    <p>⼤数据， 数理统计， 机器学习， sklearn， ⾼性能， ⼤并发。 </p>
</div>
"""

#  贪婪模式 和 非贪婪模式
# 贪婪模式：
import re
 
#贪婪模式(尽可能多的匹配字符,看例子)
 
str = "This is a number 234-235-22-423"
pattern = r"(.+)(\d+-\d+-\d+-\d+)"
result = re.match(pattern, str)
result.groups()
 
 
#分析 
#由pattern可知str被分成两组,因为默认情况下为贪婪模式,所以
#    第一组会在保证第二组符合的情况下, 尽可能的匹配多的字符
#所以推断:
#    第一组: This is a number 23
#    第二组: 4-235-22-423
# 这样既可以是第二组情况符合,而又使得第一组尽可能贪婪地匹配到最多的字符
 
# 非贪婪模式:(?加载表达式后,可以开启非贪婪模式)
import re
 
#非贪婪模式(尽可能少的匹配字符,看例子)    ? 的使用
 
str = "This is a number 234-235-22-423"
pattern = r"(.+?)(\d+-\d+-\d+-\d+)"
result = re.match(pattern, str)
result.groups()
 
 
#分析 
#由pattern可知str被分成两组,因为使用?所以为非贪婪模式,所以
#    第一组会在保证第二组符合的情况下, 尽可能的匹配少的字符
#所以推断:
#    第一组: This is a number 
#    第二组: 234-235-22-423
# 这样既可以是第二组情况符合,而又使得第一组尽可能匹配到最少的字符
 
# 正则在爬虫中的应用,爬取网页中<img>标签中图片的url连接内容
import re
 
爬取网页中<img>标签中图片的url链接内容
 
str = """<img data-original="https://rpic.douyucdn.cn/appCovers/2016/11/13/1213973_201611131917_small.jpg" src="https://rpic.douyucdn.cn/appCovers/2016/11/13/1213973_201611131917_small.jpg" style="display: inline;">"""
 
pattern1 = r"https.+\.jpg"
pattern2 = r"https.+?\.jpg"
result = re.search(pattern1, str)
result.groups()
result = re.search(pattern2, str)
result.groups()