python常用库

常见模块解析

1. math库

数学函数

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 **Python 3 已废弃，使用 (x>y)-(x。
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,…)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,…)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
round(x [,n])	返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。
sqrt(x)	返回数字x的平方根。

---

三角函数

Python的math库包括以下三角函数：(比如：math.sin(math.pi/2))

函数	描述
acos(x)	返回x的反余弦弧度值。
asin(x)	返回x的反正弦弧度值。
atan(x)	返回x的反正切弧度值。
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
cos(x)	返回x的弧度的余弦值。
hypot(x, y)	返回欧几里德范数 sqrt(xx + yy)。
sin(x)	返回的x弧度的正弦值。
tan(x)	返回x弧度的正切值。
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)	将角度转换为弧度

---

数学常量

常量	描述
math.pi	数学常量 pi（圆周率，一般以π来表示）
math.e	数学常量 e，e即自然常数（自然常数）。

2. random库

Python的random库包含以下常用随机数函数：

import random
# 生成一个 [0, 1) 范围内的随机小数
print(random.random())

# 生成一个 [1, 10] 范围内的随机整数
print(random.randint(1, 10))

# 生成一个 [0, 1] 范围内的随机小数
print(random.uniform(0, 1))

# 从序列中随机选择一个元素
seq = ['apple', 'banana', 'orange']
print(random.choice(seq))

# 将序列中的元素随机打乱（shuffle洗牌）
seq = [1, 2, 3, 4, 5]
random.shuffle(seq)
print(seq)

3. re 模块

1. 常用正则表达式

模式	描述
\w	匹配字母数字及下划线
\W	匹配非字母数字下划线
\s	匹配任意空白字符，等价于[\t,\n,\r,\f]
\S	匹配任意非空字符
\d	匹配任意数字，等价于[0-9]
\D	匹配任意非数字
\A	匹配以xx字符串开始
\Z	匹配xx字符串结束，如果是存在换行，只匹配到换行前的结束字符串
\z	匹配xx字符串结束
\G	匹配最后匹配完成的位置
\n	匹配一个换行符
\t	匹配一个制表符
^	匹配字符串的开头
$	匹配字符串的末尾
.	匹配任意字符, 除了换行符, 当 re.DOTALL 标记被指定时, 则可以匹配包括换行符的任意字符
[…]	用来表示一组字符， 单独列出：[amk] 匹配 ‘a’，‘m’ 或 ‘k’
[^…]	不在 [ ] 中的字符：[^abc] 匹配除了a， b， c之外的字符
*	匹配0个或多个的表达式
+	匹配1个或多个的表达式
?	匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
{n}	精确匹配n个前面表达式。
{n，m}	匹配n到m次由前面的正则表达式定义的片段，贪婪方式
alb	匹配a或b
()	匹配括号内的表达式，也表示一个组

注意：[ ]所有的特殊字符在字符集中都失去其原有的特殊含义,在字符集中如果要使用]、-或^，可以在前面加上反斜杠，或把]、-放在第一个字符，把^放在非第一个字符

2. 常用函数

函数	说明
re.match( )	从字符串的起始位置匹配, 匹配成功, 返回一个匹配的对象, 否则返回None
re.search( )	扫描整个字符串并返回第一个成功的匹配
re.findall( )	在字符串中找到正则表达式所匹配的所有子串, 并返回一个列表, 如果没有找到匹配的, 则返回空列表
re.split( )	将一个字符串按照正则表达式匹配结果进行分割, 返回列表类型
re.finditer( )	在字符串中找到正则表达式所匹配的所有子串, 并把它们作为一个迭代器返回
re.sub( )	把字符串中所有匹配正则表达式的地方替换成新的字符串
re.complie( )	将正则表达式传入, 返回一个匹配对象, 一般与其他方法组合使用

3. 正则匹配使用示例

print("hello".replace("llo","ooo"))  # heooo
print("hello".find("abcd"))  # -1 (找不到返回 -1)
print("hello".find("he"))    # 0

import re
print(re.findall("\w","ab* 12$ _"))  # ['a', 'b', '1', '2', '_']
print(re.findall("\s","ab* 12$ _ "))  # [' ', ' ', ' ']
print(re.findall("\Aab","ab* 12$ _"))  # ['ab']
print(re.findall("\Aaa","ab* 12$ _"))  # [] 没匹配到为空
print(re.findall("_\Z","ab* 12$ _"))   # ['_']
print(re.findall("0\Z","ab* 12$ _"))   # [] 没匹配到为空
print(re.findall("\t","ab* 12$ \t_"))    # ['\t']
#"\s" 可以匹配"\t"和"\n"
print(re.findall("^ab","ab* 12$ _"))   # ['ab']
print(re.findall("_$","ab* 12$ _\n"))  # ['_']

重复匹配

#.匹配任意一个字符
import re
print(re.findall("a.b","a\tb")) # ['a\tb']
print(re.findall("a.b","a\nb")) # [] (换行符匹配不到,匹配为空)
print(re.findall("a.b","a b a*b abb a_b")) # ['a b', 'a*b', 'abb', 'a_b']
print(re.findall("a.b","a\nb",re.S))     # ['a\nb'] (加入参数, 包含换行)
print(re.findall("a.b","a\nb",re.DOTALL))   # ['a\nb'] (同上效果一样)

#* 匹配前面那个字符0个或者n个
print(re.findall("a*","aaaa aa"))# ['aaaa', '', 'aa', ''] (零个或多个a)
print(re.findall("ab*","abab aa"))# ['ab', 'ab', 'a', 'a'] (一个a零个或多个b)
print(re.findall("a*b","ababaaaba aa")) # ['ab', 'ab', 'aaab'] (零个或多个a一个b)
print(re.findall("ab*","bbbbbbbb"))  # [] (没有匹配到一个a零个或多个b)

#? 匹配前面那个字符0个或者1个
print(re.findall("ab?","a"))     # ['a']，匹配1个a，0个b
print(re.findall("ab?","abbb"))  # ['ab']

#{n,m} 匹配n~m个
print(re.findall("a{2}","aaaa"))     # ['aa', 'aa']
print(re.findall("ab{2,6}","abbb"))  # ['abbb'] (一个a,2~6个b)
print(re.findall("ab{1,}","abbb"))   # ['abbb'] (相当于 ab+)
print(re.findall("ab{0,}","abbb"))   # ['abbb'] (相当于 ab*)

#[ ]逐个匹配
print(re.findall("a[*1_c-]b","a*ba1b a_baaba-b")) # ['a*b', 'a1b', 'a_b', 'a-b']
print(re.findall("a[^a-zA-Z0-9]b","a*banb aPbaa7b"))  # ['a*b'] (非a~z,A~Z,0~9)

#( )分组
print(re.findall('ab+','ababab123')) # ['ab', 'ab', 'ab']
print(re.findall('(ab)+123','ababab123')) # ['ab']，匹配到末尾的 ab123 中的 ab
print(re.findall('(?:ab)+123','ababab123')) 
#['ababab123']， findall的结果不是匹配的全部内容，而是组内的内容, ?: 可以让结果为匹配的全部内容,详见非捕获匹配
print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击</a>'))# ['http://www.baidu.com']
print(re.findall('href="(?:.*?)"','<a href="http://www.baidu.com">点击</a><a href="http://www.aiqiyi.com">点击2</a>'))
# ['href="http://www.baidu.com"', 'href="http://www.aiqiyi.com"']


print(re.findall("a\.b","a1b a.b"))  # ['a.b']
print(re.findall("shawn|song","shawn is man song is shawn"))  # ['shawn', 'song', 'shawn']
print(re.findall("A(?:abc|cba)A","AabcA"))  # ['AabcA']
print(re.findall("com(?:puter|e)","come on! Here is a computer "))  # ['come', 'computer']

#匹配所有数字
print(re.findall("\d+\.?\d*","12as3.45qw2k7"))  # ['12', '3.45', '2', '7']

贪婪匹配.*与懒惰匹配.*?

print(re.findall("a.*b","a11b22222b33"))  # ['a11b22222b']
print(re.findall("a.*?b","a11b22222b3"))  # ['a11b']

4. 方法示例

#re.findall(pattern,string)
	#在字符串中找到正则表达式所匹配的所有子串, 并返回一个列表, 如果没有找到匹配的, 则返回空列表
print(re.findall("(ab)+(cd)+","ababcdcd abcd"))
	#[('ab', 'cd'), ('ab', 'cd')]，返回元组列表

#re.search()
	匹配整个字符串, 只到找到第一个匹配然后返回一个包含匹配信息的对象(re.Match对象)
	该对象可以通过调用 group()方法得到匹配的字符串,如果字符串没有匹配，则返回None
	如果没有匹配到值就调用 group() 方法, 抛出异常
print(re.search("abc","112abc333abc"))  
	# <re.Match object; span=(3, 6), match='abc'>
print(re.search("abc","112abc333abc").group())  # abc

print(re.search("abcd","12abc333abc"))          # None
print(re.search("abcd","12abc333abc").group()) 
	# 报错 "AttributeError" 因为没拿到这个对象,所以没有group()属性

#re.match()
	与 re.search 功能相同, 但必须匹配起始位置, 不然返回 None
print(re.match("abc","abc22abc"))  
	# <re.Match object; span=(0, 3), match='abc'>
print(re.match("abc","abc22abc").group())  # abc
print(re.match("abc","1abc22abc"))  # None

#re.split()
	以规定字符作为分隔符对字符串进行切分, 切分结果放入列表, 没匹配到返回原字符串列表
    将规定字符放入 [ ] 则是逐个匹配
print(re.split("ab","abcoababcoabc"))  #['', 'co', '', 'co', 'c']
print(re.split("a","nbc")) #['nbc']，返回原字符串
print(re.split("[ob]","abcoabcoabc"))  # ['a', 'c', 'a', 'c', 'a', 'c']

#re.sub()和re.subn()
	匹配字符, 并将其该成指定字符, 返回改变后的字符串, 后面可跟个数参数, 不指定默认替换所有
	re.subn( ) 返回一个元组, 第二个元素返回的是替换的个数
print(re.sub("a","AA","i am a man"))  # i AAm AA mAAn
print(re.sub("a","AA","i am a man",100))  # i AAm AA mAAn，不报错
print(re.subn("a","A","i am a man"))  # ('i Am A mAn', 3) (显示替换的个数)

#re.compile()  	返回一个对象
obj=re.compile("\d{2}")
print(obj) # re.compile('\\d{2}')
print(obj.findall("ab123bc123")) #['12', '12']
print(obj.search("ab123bc123").group())	# 12
print(obj.match("123ab123bc123").group())	# 12

substitude 替换

5. 非捕获匹配?: ?! ?=

# ?:
	(?:)非捕获分组，只会进行单纯的模式匹配并不会将匹配到的值进行保存，与()区分
print(re.findall("jk(loli)+","jkloli")) # ['loli']
print(re.findall("jk(?:loli)+","jkloli")) # ['jkloli']

# ?!	正向否定预查
	1.在没匹配到字符串的前提下，再进行后续的正则，后续匹配仍然从被匹配字符串的头开始
res = re.match("(?![\d]+$)(?![a-zA-Z]+$)[\da-zA-Z]{6}$",passwd)
	#匹配6位数字与字母组合，不能纯数字或字母
    2.匹配位置 后面 不能跟着指定表达式。
print(re.findall("19(?!99)","1999"))
print(re.findall("\d{2}(?!99)","1999 1988"))#['99', '19', '88']
	#先尝试匹配"1999"，再'999 '(成功)，再"9 19"，再" 198"，再"1988"(成功)，再"88",理解下匹配的窗格移动
    
# ?=  正向肯定预查
	1.在匹配到字符串的前提下，再进行后续的正则，后续匹配仍然从被匹配字符串的头开始
res = re.search("(?=.*[\d])(?=.*[a-z])(?=.*[A-Z])(?=.*)(?=.*[!@#%&])^([\da-zA-Z!@#%&]{7,})$",passwd)
	#至少七位密码，包含大小写，数字，特殊字符(!,@,#,%,&)
    
    2.匹配位置 后面 必须跟着指定表达式。
r"foo(?=bar)"可以匹配foobar中的foo，不能匹配foobaz中的foo
    

# ?<=
	匹配位置 前面 必须跟着指定表达式。
print(re.findall("(?<=jk).*?(?=li)","mcjli jkloli liejk"))   #['lo']

# ?<!
	匹配位置 前面 不能跟着指定表达式。
	print(re.findall("\\B(?<!18)\d{2}\\b","1988  1899")) #['88']
	

6. 边界匹配问题

\b表示单词边界，\B表示非单词边界

一般空格、换行、标点符号或者特殊符号来表示边界

或者说非数字、字母、下滑线、unicode汉字表示边界

中文字符串为边界的话要用re.A编码模式

print(re.findall("\\b19(?:[^9]{2})\\b","1999  1988")) #['1988']

print(re.findall("\\b19(?:[^9]{2})\\b","你也玩1999?1988带我一个",re.A))
	# ['1988']

4. request模块

5. time库

6. urllib

from urllib.parse import unquote