python常用函数总结

print("hello world")

print("hello","how","are","you")

hello how are you

>>>print(300) 300
>>>print(100 + 200) 300

>>>print("100 + 200 =", 100 + 200) 100 + 200 = 300

print("hello","你好") # 使用”,“进行连接

print("he" + "llo") # 字符串相加，进行字符串的连接，且不产生空格

print(10+30) # 没有使用引号括起来，默认为数值，若是使用引号括起来，就是字符串 # 若是数值使用加号连接，默认是表达式进行计算，返回计算的结果

print("hello"+1) #会报错 # 不同类型的数据不能使用加号连接 # 不同类型的数据能够使用”,“进行连接
print("1 2 3",2+3) # 输入 # input() # 带有提示信息的输入 # name = input("请输入您的姓名：") # print(name)

n = 0 while n <= 100: print("n =",n,end=' ') if n == 20: break n += 1 输出： n = 0 n = 1 n = 2 n = 3 n = 4 n = 5 n = 6 n = 7 n = 8 n = 9 n = 10 n = 11 n = 12 n = 13 n = 14 n = 15 n = 16 n = 17 n = 18 n = 19 n = 20 ————————————————

print('c'>'b'>'a') print(5>1>2) 输出： True False

>>> name = input() jean

>>> name 'jean'

>>> print(name) jean

>>> name = input("place enter your name") place input your name jean >>> print("hello,", name) hello, jean

>>> bin(10) '0b1010'

>>> oct(12) '014'

>>> hex(12) '0xc'

>>>'{0:b}'.format(10) '1010'

>>> '{0:o}'.format(12) '14'

>>> '{0:x}'.format(12) 'c'

>>> int('1010',2) 10

>>> int('014', 8) 12

>>> int('0xc',16) 12

>>> '{0:d}'.format(0b11) '3'

>>> '{0:d}'.format(0o14) '12'

>>> '{0:d}'.format(0x1f) '31'

>>> eval('0b11') '3'

>>> eval('0o14') '12'

>>> eval('0x1f') '31'

#借助十进制
>>> bin(int('fc',16)) '0b11111100'
#利用函数直接转
>>> bin(0xa) '0b1010'
>>> oct(0xa) '012'
>>> hex(10) '0xa'

n = "hello world" n = type(n) print(n) 输出： <class 'str'>

# int float str bool tuple list dict set
str1 = 'ss'
if type(num) == str: print('yes') 输出： yes

str1 = 'ss'
print(isinstance(str1,str)) 输出： True

class A(): pass

class B(A): def __init__(self): super(B, self).__init__() pass

class C(A): def __init__(self): A.__init__(self) n = 0.1
print(isinstance(n,(int,float,str))) print(isinstance(n,int)) print(isinstance(A,object)) b = B() print(isinstance(b,A)) c =C() print(isinstance(c,B)) 输出： True False True True False 

import keyword print(keyword.kwlist) 输出： ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

n = "hello world"
print(n) del n

n = "hello world"
print(n) del(n) print(n) 输出： hello world NameError: name 'n' is not defined

print(abs(-3)) 输出： 3

num1 = 10 num2 = 20
print(num1 > num2) print(max(num1,num2,56)) 输出： False 56

print(min(12,3,34,0)) 输出： 0

print(pow(2,3)) 输出： 8

print(round(123.486,2)) 输出： 123.49

''' 需求：使用for循环计算1*2*3...*20的值 ''' accou = 1
for i in range(1,21): accou *= i print(accou) 输出： 2432902008176640000

# 12-3 --> 9
str1 = "12-3"
print(eval(str1)) print(str1) print(eval("[1,2,3,4]")) print(type(eval("[1,2,3,4]"))) print(eval("(1,2,3,4)")) print(eval('{1:1,2:2,3:3}')) print(eval('{2,3,5,3}')) 输出： 9
12-3 [1, 2, 3, 4] <class 'list'> (1, 2, 3, 4) {1: 1, 2: 2, 3: 3} {2, 3, 5}

str1 = "you are good man"
print(len(str1)) 输出： 16

str1 = "You are good Man"
print(str1.lower()) print(str1) 输出： you are good man You are good Man

str1 = "You are good man"
print(str1.upper()) print(str1) 输出： YOU ARE GOOD MAN You are good man

str1 = "You are Good man"
print(str1.swapcase()) print(str1) 输出： yOU ARE gOOD MAN You are Good man

tr1 = "you Are good man"
print(str1.capitalize()) print(str1) str2 = "You are a good Man"
print(str2.capitalize()) 输出： You are good man you Are good man 

str1 = "you Are good man"
print(str1.title()) print(str1) str2 = "You are a good Man"
print(str2.title()) 输出： You Are Good Man you Are good man You Are A Good Man

str1 = "you Are good man"
print(str1.center(20,"*")) print(str1) 输出： you Are good man **you Are good man** you Are good man

str1 = "you Are good man"
print(str1.ljust(20,"*")) print(str1) 输出： you Are good man**** you Are good man

str1 = "you Are good man"
print(str1.rjust(20,"*")) print(str1) 输出： ****you Are good man you Are good man

str1 = "you Are good man"
print(str1.zfill(20)) print(str1) 输出： 0000you Are good man

str1 = "hello" str2 = "Hello hello1 Hello2 hi haha helloa Are good man"
print(str2.count(str1,0,20)) 输出： 1

str1 = "hello" str2 = "Hello hello1 Hello2 hi haha helloa Are good man"
print(str2.find(str1,5,20)) 输出： 6

str1 = "hello" str2 = "Hello hello1 Hello2 hi haha helloa Are good man"
print(str2.rfind(str1,10,35)) 输出; 28

str1 = "hello" str2 = "Hello hello1 Hello2 hi haha helloa Are good man"
print(str2.index(str1,2,25)) print(str2.index(str1,24,25)) 输出： 6 ValueError: substring not found

str3 = " \n\r \t ni hao ma"
print(str3) print(str3.lstrip()) str4 = "****ni hao ma****"
print(str4.lstrip('*')) 输出; ni hao ma ni hao ma ni hao ma****

str3 = " ni hao ma \n\r \t"
print(str3.rstrip()) str4 = "****ni hao ma****"
print(str4.rstrip('*')) 输出： ni hao ma ****ni hao ma

str2 = "22hello nihao hi hello haha ello2 hello3 hello"
print(str2.split(' ',3)) str3 = "1257309054@qq.com"
print(str3.split('@')) list1 = str3.split('@') print(list1[1].split('.')) 输出： ['22hello', 'nihao', 'hi', 'hello haha ello2 hello3 hello'] ['1257309054', 'qq.com'] ['qq', 'com']

str2 = ''' 22 23 hello '''
print(str2.splitlines()) 输出： ['', '22', ' 23', ' hello']

list1 = ["hello","nihao"] print(" ".join(list1)) 输出： hello nihao

str1 = "how are you , i am fine thank you" str3 = "*".join(str1) print(str3) 输出： h*o*w* *a*r*e* *y*o*u* *,* *i* *a*m* *f*i*n*e* *t*h*a*n*k* *y*o*u

print(ord("a")) 输出： 97

print(chr(97)) 输出： a

str1 = "how are you , i am fine thank you"
print(max(str1)) 输出： y

str1 = "how are you , i am fine thank you"
print(min(str1)) 输出： ' '

str1 = "you are a good man"
print(str1.replace("good","nice")) 输出： you are a nice man

str1 = "you are a good man" dic = str1.maketrans("ya","32") print(str1.translate(dic)) 结果： 3ou 2re 2 good m2n

str1 = "hello man"
print(str1.startswith("h",0,6)) 输出： True

str1 = "hello man"
print(str1.endswith("man")) 输出： True

str4 = "你好吗"
print(str4.encode()) print(str4.encode().decode()) print(str4.encode("gbk")) print(str4.encode("gbk").decode("gbk")) 输出： b'\xe4\xbd\xa0\xe5\xa5\xbd\xe5\x90\x97' 你好吗 b'\xc4\xe3\xba\xc3\xc2\xf0' 你好吗

str5 = "hello你二"
print(str5.isalpha()) str5 = "hello "
print(str5.isalpha()) 输出： True False

str5 = "helloA标红"
print(str5.isalnum()) print("12aaa".isalnum()) print("aaa".isalnum()) print(" 111".isalnum()) print("111".isalnum()) print("$$%%qwqw11".isalnum()) print("你好".isalnum()) print( "IV".isalnum()) print('Ⅳ'.isalnum()) 输出; True True True False True False True True True

print("WWW".isupper()) print("wWW".isupper()) print("123".isupper()) print("一二三".isupper()) 输出; True False False False

print("WWW".islower()) print("wWW".islower()) print("123".islower()) print("一二三".islower()) print("qwww".islower()) 输出： False False False False True

print("U Wss".istitle()) print("wWW ".istitle()) print("123 ".istitle()) print("一二三".istitle()) print("qwww".istitle()) 输出： True False False False False

print("123".isdigit()) print("123".isdigit()) print(b"1".isdigit()) print("Ⅳ".isdigit()) print("123.34".isdigit()) print("一".isdigit()) 输出; True True True False False False

print("ddd".isspace()) print("".isspace()) print("a ddd".isspace()) print(" aaa".isspace()) print("  ".isspace()) 输出; False False False False True

isnumeric()
True: Unicode数字，全角数字（双字节），汉字数字
False: 罗马数字，
Error: byte数字（单字节）

isdecimal()
True: Unicode数字，，全角数字（双字节），
False: 罗马数字，汉字数字
Error: byte数字（单字节）

print("123".isdecimal()) print("123z".isdecimal()) #结果
True False

list1 = [1,2,3,4] list2 = ["good","nice","beautiful"] list1.append("hello") print(list1) list1.append(list2) print(list1) 输出： [1, 2, 3, 4, 'hello', ['good', 'nice', 'beautiful']]

2、list1.extend() 功能：在列表的末尾一次性追加另一个列表中的多个值 注意：extend()中的值，只能是列表、元组、字符串、字典（可迭代的对象）

list1 = [1,2,3,4] list2 = ["good","nice","beautiful"] list1.extend(list2) print(list1) list1.extend({'h':2,'e':3}) print(list1) 输出： [1, 2, 3, 4, 'good', 'nice', 'beautiful'] [1, 2, 3, 4, 'good', 'nice', 'beautiful', 'h', 'e']

什么时候使用append，什么时候用extend?
当我们需要在原本的列表中追加像number类型后者Boolean类型的时候，
可以使用append，
或者是我们需要把另外一个列表当成一个元素追加到原本的列表中去的时候，
这时候也可以使用append

当我们需要在原本的列表中插入一个新的列表中的所有的元素的时候，
这时候我们需要使用extend

list1 = [1,2,3,4] list2 = ["good","nice","beautiful"] list1.insert(0,list2) print(list1) 输出： [['good', 'nice', 'beautiful'], 1, 2, 3, 4]

list2 = ["good","nice","beautiful"] list2.pop() print(list2) list1 = [1,2,3,4] list2.pop(0) print(list2) list2.extend(list1) print(list2) 输出： ['good', 'nice'] ['nice'] ['nice', 1, 2, 3, 4]

list2 = [2,"good","nice","beautiful",2] list2.remove(2) print(list2.remove(2)) print(list2) 输出: None ['good', 'nice', 'beautiful']

list2 = [2,"good","nice","beautiful",2] list2.clear() print(list2.clear()) print(list2) 输出： None []

list2 = [2,"good","nice","beautiful",2] del list2 print(list2) 输出： NameError: name 'list2' is not defined 因为列表已经删除了，所以不能再访问，否则会出错

list1 = ['h','e','l','l','o'] print(list1.index('e')) 输出： 1

list1 = [1,2,3,4,5,1] print(list1.count(1)) 输出： 2

list1 = [1,2,3,4,5,[1,3,4]] print(len(list1)) 输出： 6

list1 = [1,2,3,4,5] print(max(list1)) print(min(list1)) list2 = ['hello','he','hl','hl','ho'] print(max(list2)) print(min(list2)) 输出： 5
1 ho he

list3 = [2,1.22,3,6,33] list4 = ['hello','nihao','how are you'] list3.reverse() list4.reverse() print(list3) print(list4) 输出： [33, 6, 3, 1.22, 2] ['how are you', 'nihao', 'hello']

list4 = ['hello','nihao','how are you'] list4.sort() print(list4) list4 = [2,3,1,2,4] list4.sort() print(list4) 输出： ['hello', 'how are you', 'nihao'] [1, 2, 2, 3, 4]

list1 = [1,3,2,4,5,6] list1.sort(reverse=True) print(list1) 输出： [6, 5, 4, 3, 2, 1]

list1 = [1,3,2,4,5,6] y = list1.copy() x = list1[:] print(sorted(list1,reverse=True)) print(list1) print(y) print(id(list1)) print(id(y)) print(x) print(id(x)) 输出： [6, 5, 4, 3, 2, 1] [1, 3, 2, 4, 5, 6] [1, 3, 2, 4, 5, 6] 3232179914952
3232179037832 [1, 3, 2, 4, 5, 6] 3232179914824

list1 = ['hello','nihao','how are you'] list2 = list1 print(id(list1)) print(id(list2)) list3 = list1.copy() print(id(list3)) 输出; 1670426304008
1670426304008
1670426233032

list1 = list((1,2,3)) print(list1) 输出: [1, 2, 3]

tuple4 =(1,3,2,4,5,3) print(len(tuple4)) print(max(tuple4)) print(min(tuple4)) print(tuple([1, 2, 3, 4, 6])) 输出： 6
5
1 (1, 2, 3, 4, 6)

dict1 = {"key1":1,"key2":2} print(dict1.get("key1")) 输出： 1

dict1 = {"key1":1,"key2":2} print(dict1.pop("key1")) print(dict1.pop("key2")) print(dict1) 输出: 1
2 {} 

set1 = {'key1','key2'} set1.add('key1') set1.add('key3') print(set1) 输出; {'key1', 'key2', 'key3'}

set1 = {'key1','key2'} set1.update(['key3','key4']) set1.update(('hello',True)) set1.update('key5') print(set1) 输出; {'key3', True, '5', 'key1', 'y', 'key4', 'key2', 'k', 'hello', 'e'}

set1 = {'key1','key2'} set1.remove('key1') print(set1) set1.remove('key3') 输出; {'key2'} 报错：KeyError: 'key3'

mystack = [] #压栈[向栈中存数据]
mystack.append(1) print(mystack) mystack.append(2) print(mystack) mystack.append(3) print(mystack) #出栈[从栈中取数据]
mystack.pop() print(mystack) mystack.pop()

#导入数据结构的集合
import collections queue = collections.deque([1, 2, 3, 4, 5]) print(queue) #入队[存数据]
queue.append(8) print(queue) queue.append(9) print(queue) #取数据
print(queue.popleft()) print(queue)

# 导入模块
import math

number1 = 12.045 num1 = math.ceil(number1) print(num1) 输出： 13

number2 = 12.823 num2 = math.floor(number2) print(num2) 输出： 12

# python默认处理的数据长度是无限大，但由于计算机的数据长度有限，所以处理浮点数会出现误差值
number1 = 12.045 number2 = 12.823
print(math.modf(number1)) print(math.modf(number2)) 输出： (0.04499999999999993, 12.0) (0.8230000000000004, 12.0)

print(math.sqrt(4)) 输出： 2.0

# 导入模块
import random

num1 = random.choice(['hello',True,1,[1,4,5]]) print(num1) 输出（每次输出的结果不一定一样）： 1

random.randrange(100) print(num2)# 去头去尾
num3 = random.randrange(80,100,2) print(num3)# 取一个1~6的随机数
print(random.randrange(1,7)) 输出（每次输出的结果不一定一样）： 83
84
6

num4 = random.random() print(num4) 输出（每次输出的结果不一定一样）: 0.8073295394931393

list1 = [1,2,3,5,6,7] random.shuffle(list1) print(random.shuffle(list1)) # 返回结果为None
print(list1) 输出（每次输出的结果不一定一样）: None [1, 7, 5, 6, 3, 2]

print(random.uniform(5,4)) 输出（每次输出的结果不一定一样）: 4.697767338612918

print(random.randint(-1,4)) 输出（每次输出的结果不一定一样）： 0

import os print(os.getcwd())

列举目录下所有的文件,返回的是列表类型

import os print(os.listdir("c:\file"))

import os print(os.path.abspath("."))

功能: 将路径分解为(文件夹,文件名),返回的是元组类型

import os print(os.path.split(r"D:\python\file\hello.py")) #结果
('D:\python\file','hello.py') print(os.path.split(".")) #结果
('','.') os.path.split('D:\\pythontest\\ostest\\') #结果
('D:\\pythontest\\ostest', '') os.path.split('D:\\pythontest\\ostest') ('D:\\pythontest', 'ostest')

>>> import os >>> os.path.join(r"d:\python\test",'hello.py') 'd:\pyhton\test\hello.py'
>>> os.path.join(r"d:\pyhton\test\hello.py",r"d:\pyhton\test\hello2.py") 'd:\pyhton\test\hello2.py'

>>> import os >>> os.path.dirname(r"d:\pyhton\test\hello.py") 'd:\pyhton\test'
>>> os.path.dirname(".") ''
>>> os.path.dirname(r"d:\pyhton\test\") 'd:\pyhton\test'
>>> os.path.dirname(r"d:\pyhton\test") test

>>> import os >>> os.path.basename(r"d:\pyhton\test\hello.py") 'hello.py'
>>> os.path.basename(".") '.'
>>> os.path.basename(r"d:\pyhton\test\") ''
>>> os.path.basename(r"d:\pyhton\test") 'test'

>>> import os >>> os.path.getsize(r"d:\pyhton\test\hello.py") 38L
>>> os.path.getsize(r"d:\pyhton\test") 0L

>>> import os >>> os.listdir(os.getcwd()) ['hello.py','test.txt'] >>> os.path.exists(r"d:\python\test\hello.py") True >>> os.path.exists(r"d:\python\test\hello1.py") False

>>> import os >>>os.path.isdir(r"C:\Users\zhangjiao\PycharmProjects\day01") True >>>os.path.isdir(r"C:\Users\zhangjiao\PycharmProjects\day01\hello.py") False

import os print(os.path.isfile(r'C:\360用户文件')) print(os.path.isfile(r'C:\core.dmp')) 输出： False True

import sys #实现从程序外部向程序传递参数
print(sys.argv) #当前程序名
sys.argv[0] #第一个参数
sys.argv[1]

#mac
>>> import sys >>> sys.platform 'darwin'

>>> import sys >>> sys.path ['', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python36.zip', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/lib-dynload', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages']

# 引入了第三方库
from PIL import Image #打开图片,路径需要注意
im = Image.open("test.png") #查看图片的信息
print(im.format, im.size, im.mode) # 设置图片的大小,注意:图片的大小给定的是个元组
im.thumbnail((200, 100)) #保存成新的图片
im.save("thum.jpg","JPEG") 输出： PEG (497, 325) RGB

''' %a 本地(local) 简化星期名称 %A 本地完整星期名称 %b 本地简化月份名称 %B 本地完整月份名称 %c 本地相应的日期和时间表示 %d 一个月中的第几天（01-31） %H 一天中的第几个小时（24小时制00-23） %I 第几个小时（12小时制01-12） %j 一年中的第几天（001-366） %m 月份（01-12） %M 分钟数（00-59） %p 本地am或pm的相应符 %S 秒（01-60） %U 一年中的星期数。（00-53 星期天是一个星期的开始）第一个星期天之前的所有天数都放在第0周 %w 一个星期中的第几天（0-6 0是星期天） %W 和%U基本相同，不同的是%W以星期一为一个星期的开始 %x 本地相应日期 %X 本地相应时间 %y 去掉世纪的年份（00-99） %Y 完整的年份 %z 时区的名字 %% '%'字符 '''
import time time1 = time.time() lt = time.localtime(time1) st = time.strftime('''a: %a |A: %A |b: %b |B: %B |c: %c |d: %d H: %H |I: %I |j: %j |m: %m |M: %M |p: %p S: %S |U: %U |w: %w |W: %W |x: %x |X: %X y: %y |Y: %Y |z: %z |%% ''',lt) print(st) 输出： a: Thu |A: Thursday |b: Apr |B: April |c: Thu Apr 12 17:15:19 2018 |d: 12 H: 17 |I: 05 |j: 102 |m: 04 |M: 15 |p: PM S: 19 |U: 14 |w: 4 |W: 15 |x: 04/12/18 |X: 17:15:19 y: 18 |Y: 2018 |Z: +0800 |% 

1.时间戳 以整数或浮点型表示的是一个秒为单位的时间间隔,这个时间的基础值1970.1.1的零点开始算起 2.元组格式 采用python的数据结构表示,这个元组有9个整型内容,分别表示不同含义 year month day hours minutes seconds weekday Julia days flag[1 夏令时 -1 根据当前时间判断 0 正常表示] 3.格式化字符串 

import time

print(time.clock()) time.sleep(2) print(time.clock()) 输出： 0.0
2.0007889054974255

print(time.clock()) 输出： 4.665319322446344e-07

import time start = time.clock() for cock in range(5,101,5):   # 公鸡
    for hen in range(3,101 - cock,3):  #母鸡
        for chick in range(1,101 - cock - hen): #小鸡
            if cock // 5 + hen // 3 + chick * 3 == 100 and cock + hen + chick == 100: pass end = time.clock() time2 = end - start print("方案二所花时间",time2) 输出： 方案二所花时间 0.0041665966868768296

time1 = time.time() print(time1) 输出： 1523427779.9672592

time1 = time.time() gm = time.gmtime(time1) print(gm) 输出： time.struct_time(tm_year=2018, tm_mon=4, tm_mday=11, tm_hour=6, tm_min=22, tm_sec=59, tm_wday=2, tm_yday=101, tm_isdst=0)

time1 = time.time() lm = time.localtime(time1) print(lm) 输出： time.struct_time(tm_year=2018, tm_mon=4, tm_mday=11, tm_hour=14, tm_min=22, tm_sec=59, tm_wday=2, tm_yday=101, tm_isdst=0)

lm2 = time.localtime(1523328000) time2 = time.mktime(lm2) print(time2) 输出： 1523328000.0

lm2 = time.localtime(1523328000) st = time.asctime(lm2) print(st) 输出： Tue Apr 10 10:40:00 2018

time1 = time.time() ct = time.ctime(time1) print(ct) 输出： Wed Apr 11 15:18:35 2018

time1 = time.time() lm = time.localtime(time1) sct = time.strftime("%Y-%m-%d %X",lm) print(sct) 输出： 2018-04-11 15:18:35

strp = time.strptime('2018-04-10 11:12:57',"%Y-%m-%d %X") print(strp) 输出： time.struct_time(tm_year=2018, tm_mon=4, tm_mday=10, tm_hour=11, tm_min=12, tm_sec=57, tm_wday=1, tm_yday=100, tm_isdst=-1)

datetime:同时有时间与日期

timedelta:表示时间间隔,即两个时间点的间隔:主要用于计算时间的跨度

tzinfo: 时区相关的信息

date : 只关注日期

import datetime

t1 = datetime.datetime.now() print(t1) 输出： 2018-04-11 19:52:06.180339

time2 = datetime.datetime(2018, 3, 28, 21, 59, 7, 95015) print(time2) print(type(time2)) 输出： 2018-03-28 21:59:07.095015
<class 'datetime.datetime'>

time1 = datetime.datetime.now() time3 = time1.strftime("%Y-%m-%d") print(time3) 输出： 2018-04-11

import datetime import time time1 = datetime.datetime.now() time.sleep(3) time2 = datetime.datetime.now() time3 = time2 -time1 print(time1) print(time2) print(time3) print(type(time3)) #间隔天数
print(time3.days) # 间隔天数之外的时间转为秒
print(time3.seconds) 输出： 2018-04-11 20:06:11.439085
2018-04-11 20:06:14.440052 0:00:03.000967
<class 'datetime.timedelta'> 0 3

import calendar

print(calendar.month(2018,4)) print(type(calendar.month(2018,4))) 输出： April 2018 Mo Tu We Th Fr Sa Su 1
 2  3  4  5  6  7  8
 9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30

<class 'str'>

print(calendar.firstweekday()) 输出： 0

print(calendar.isleap(2016)) 输出： True

print(calendar.leapdays(2000,2020)) 输出： 5

返回一个元组(参数一，参数二) 参数一：当月的天数 参数二：当月第一天的日期码[0,6][周一，周日]

print(calendar.monthrange(2018,1)) print(calendar.monthrange(2018,2)) print(calendar.monthrange(2018,3)) print(calendar.monthrange(2018,4)) 输出： (0, 31) (3, 28) (3, 31)

print(calendar.monthcalendar(2018,4)) 输出： [[0, 0, 0, 0, 0, 0, 1], [2, 3, 4, 5, 6, 7, 8], [9, 10, 11, 12, 13, 14, 15], [16, 17, 18, 19, 20, 21, 22], [23, 24, 25, 26, 27, 28, 29], [30, 0, 0, 0, 0, 0, 0]]

print(calendar.weekday(2018,4,1)) 输出： 6

print(f.readline()) for line in f.readlines(): print(line.strip() #去掉换行符

from io import StringIO f = StringIO() f.write("hello") f.write("    ") f.write('world') #获取写入后的str
print(f.getvalue()) 输出： hello world

from io import StringIO f = StringIO("Hello\nHi\nGoodBye!") while True: s = f.readline() if s == '': break
    # 去掉换行符
    print(s.strip()) 输出： Hello Hi GoodBye!

from io import BytesIO f = BytesIO() f.write("中文".encode('utf-8')) print(f.getvalue()) 输出： b'\xe4\xb8\xad\xe6\x96\x87'

from io import BytesIO f = BytesIO(b'\xe4\xb8\xad\xe6\x96\x87') d = f.read() print(d) print(d.decode()) 输出： b'\xe4\xb8\xad\xe6\x96\x87' 中文

import pickle d = dict({"name":"lili","age":18}) #pickle.dumps()方法把任意对象序列化成一个bytes，然后就可以把bytes写入文件
print(pickle.dumps(d)) #把序列化后的对象写入文件
f = open("t1.txt",'wb') #参数一：要写入的对象， 参数二：写入文件的对象
pickle.dump(d,f) f.close() #从文件中读取序列化后的对象
f2 = open("t1.txt","rb") #pickle.load()反序列化对象
d = pickle.load(f2) f2.close() print(d) print(type(d)) 输出： {'name': 'lili', 'age': 18} <class 'dict'>

import json dict1 = {"name":"lili","age":18} ji = json.dumps(dict1) print(type(ji)) with open("dd.txt","w") as f: json.dump(dict1,f) with open("dd.txt","r",encoding="utf-8") as f: du = json.load(f) print(du) print(type(du)) 输出： <class 'str'> {'name': 'lili', 'age': 18}

import json class Student(object): def __init__(self, name, age, score): self.name = name self.age = age self.score = score # 将student对象转换为dict
def student2dict(std): return { 'name': std.name, 'age': std.age, 'score': std.score } s = Student('Bob', 20, 88) # 参数一：要传入的对象 参数二：将对象转为dict的函数
d = json.dumps(s, default=student2dict) # 将dict转为对象
def dict2student(d): return Student(d['name'], d['age'], d['score']) jsonStr = '{"age": 20, "score": 88, "name": "Bob"}'
# json反序列化为一个对象 # 参数一：json字符串，参数二：dict转为对象的函数
print(json.loads(jsonStr, object_hook=dict2student)) # 写入文件
with open("t1.txt","w") as f: f.write(d) # 读取文件
with open("t1.txt","r",encoding="utf-8") as f: du = json.load(f,object_hook=dict2student) print(du) 输出： <__main__.Student object at 0x000002CA795AA0F0>
<__main__.Student object at 0x000002CA7975B0F0>

import csv def readCsv(path): #列表
    infoList = [] #以只读的形式打开文件
    with open(path, 'r') as f: #读取文件的内容
        allFileInfo = csv.reader(f) #将获取到的内容逐行追加到列表中
        for row in allFileInfo: infoList.append(row) return infoList path = r"C:\Users\xlg\Desktop\001.csv"

import csv #以写的方式打开文件
def writeCsv(path,data) with open(path,'w',newline='') as f: writer = csv.writer(f) for rowData in data: print("rowData =", rowData) #按行写入
 writer.writerow(rowData) path = r"C:\Users\xlg\Desktop\002.csv" writeCsv(path,[[1,2,3],[4,5,6],[7,8,9]])  

import sys import importlib importlib.reload(sys) from pdfminer.pdfparser import PDFParser, PDFDocument from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter #解释器
from pdfminer.converter import PDFPageAggregator #转换器
from pdfminer.layout import LTTextBoxHorizontal, LAParams #布局
from pdfminer.pdfinterp import PDFTextExtractionNotAllowed #是否允许pdf和text转换

def readPDF(path, toPath): #以二进制形式打开pdf文件
    f = open(path, "rb") #创建一个pdf文档分析器
    parser = PDFParser(f) #创建pdf文档
    pdfFile = PDFDocument() #链接分析器与文档对象
 parser.set_document(pdfFile) pdfFile.set_parser(parser) #提供初始化密码
 pdfFile.initialize() #检测文档是否提供txt转换
    if not pdfFile.is_extractable: raise PDFTextExtractionNotAllowed else: #解析数据
        #数据管理器
        manager = PDFResourceManager() #创建一个PDF设备对象
        laparams = LAParams() device = PDFPageAggregator(manager, laparams=laparams) #解释器对象
        interpreter = PDFPageInterpreter(manager, device) #开始循环处理，每次处理一页
        for page in pdfFile.get_pages(): interpreter.process_page(page) layout = device.get_result() for x in layout: if (isinstance(x, LTTextBoxHorizontal)): with open(toPath, "a") as f: str = x.get_text() #print(str)
                        f.write(str+"\n") path = r"0319开始.pdf" toPath = r"n.txt" readPDF(path, toPath)

#python内置了map()和reduce()函数
''' def myMap(func,li): resList = [] for paser in li: res = func(paser) resList.append(res) '''

#一、map() #原型 map(func, lsd) #将单个字符转成对应的字面量整数
def chrToint(chr): return {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}[chr] list1 = ["2","1","4","5"] res = map(chrToint, list1) #[chr2int("2"),chr2int("1"),chr2int("4"),chr2int("5")]
print(res) print(list(res)) #将整数元素的序列，转为字符串型 #[1，2，3，4] --》[“1”，“2”，“3”，“4”]
l = map(str,[1,2,3,4]) print(list(l)) 输出： <map object at 0x0000028288E76780> [2, 1, 4, 5] ['1', '2', '3', '4']

num = int(input("请输入一个数：")) map1 = map(lambda n: n*n,range(1,num+1)) print(list(map1)) 输出： 请输入一个数：4 [1, 4, 9, 16]

from functools import reduce #需求，求一个序列的和
list2 = [1, 2, 3, 4] def mySum(x,y) return x+y r = reduce(mySum,list2) print("r=",r) 输出： r= 10

from functools import reduce #将字符串转成对应字面量数字
def strToint(str1) def fc(x, y): return x*10 + y def fs(chr): return {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}[chr] return reduce(fc,map(fs,list(str1))) a = strToint("12345") print(a) print(type(a)) #模拟map()函数
def myMap(func,li): resList = [] for n in li: res = func(n) resList.append(res) 输出： 12345
<class 'int'>

from functools import reduce ''' 求1!+2!+3!+...+n!之和 ''' num = int(input("请输入一个正数：")) def jiecheng(n): ji = 1
    for i in range(1,n+1): ji *= i return ji list1 = reduce(lambda x,y: x + y ,map(jiecheng,range(1,num+1))) print(list1) 输出： 请输入一个正数：5
153

''' 语法： filter(func,lsd) 参数一：函数名 参数二：序列 功能：用于过滤序列 简单理解：把传入的函数依次作用于序列的每一个元素，根据返回的True还是False，决定是否保留该元素。 '''
#需求：将列表中的偶数筛选出来。
list1 = [1,2,3,4,5,6,7,8] #筛选条件
def func(num): #保留偶数元素
    if num%2 == 0: return True #剔除奇数元素
    return False list2 = filter(func,list1) print(list2) print(list(list2)) print(list1) 输出： <filter object at 0x0000026E74106B38> [2, 4, 6, 8] [1, 2, 3, 4, 5, 6, 7, 8]

data= [["姓名","年龄","爱好"],["tom", 25, "无"],["hanmeimei", 26, "金钱"]]

data= [["姓名","年龄","爱好"],["tom", 25, "无"],["hanmeimei", 26, "金钱"]] def filterWu(list1): for i in list1: if i == "无": return False return True dataFilter = list(filter(filterWu,data)) print(dataFilter) 输出： [['姓名', '年龄', '爱好'], ['hanmeimei', 26, '金钱']]

import calendar print(list(filter(calendar.isleap,range(2000,2020)))) 输出： [2000, 2004, 2008, 2012, 2016]

sorted(iterable,key,reverse)作用：实现对列表的排序。

iterable：是可迭代类型; cmp：用于比较的函数，比较什么由key决定; key：用列表元素的某个属性或函数作为关键字，有默认值，迭代集合中的一项; reverse：排序规则. reverse = True 降序 或者 reverse = False 升序，默认值为False。 返回值：是一个经过排序的可迭代类型，与iterable一样。

#排序 #第一类：冒泡 选择 #第二类：快速，插入，计数器 #注意：如果数据量小的情况下，上述两类用法的效率基本相同，但是，如果数据量大的情况下，第一类的效率很低

#1.普通排序
list1 = [4,3,5,6,1] #默认为升序排序
list2 = sorted(list1) print(list2) #2.按绝对值大小排序
list3 = [4，-3，5，2，-9] #key接受函数来实现自定义排序规则 #abs表示通过绝对值进行排序
list4 = sorted(list3, key=abs) #利用map可以实现取绝对值之后的排序
list5 = sorted(map(abs,list3)) print(list3) print(list4) print(list5) #3.降序排序
list5 = [2,1,4,5,6,7] #通过设置reverse=True来表示反转
list6 = sorted(list5,reverse=True) print(list5) print(list6) list7 = ['a','b','c','d'] list8 = sorted(list7) print(list7) #同样也可以实现升序排列，结果为abcd，排序依据为ASCII值
print(list8) #自定义函数：按照字符串的长短来进行排序
def myLen(str1)： return len(str1) list7 = ['sddd','dded','et54y5','6576986oy','sa','sda'] #使用自定义函数，进行排序，key=函数名
list8 = sorted(list7, key = myLen) print(list7) print(list8) 输出： [1, 3, 4, 5, 6] [4, -3, 5, 2, -9] [2, -3, 4, 5, -9] [2, 3, 4, 5, 9] [2, 1, 4, 5, 6, 7] [7, 6, 5, 4, 2, 1] ['a', 'b', 'c', 'd'] ['a', 'b', 'c', 'd'] ['sddd', 'dded', 'et54y5', '6576986oy', 'sa', 'sda'] ['sa', 'sda', 'sddd', 'dded', 'et54y5', '6576986oy']

class Student(object): def __init__(self,name,age): self.name = name self.age = age def __str__(self): return self.name +" "+ str(self.age) stu1 = Student('lili1',18) stu2 = Student('lili2',19) stu3 = Student('lili3',17) stu4 = Student('lili4',20) stu5 = Student('lili5',20) list2 = [stu1,stu2,stu3,stu4,stu5] def com(Student): return Student.age list3 = sorted(list2,key=lambda Student: Student.age) for i in list3: print(i) 输出： lili3 17 lili1 18 lili2 19 lili4 20

import itertools #概念：从n个不同元素中取出m（m≤n）个元素，按照一定的顺序排成一列，叫做从n个元素中取出m个元素的一个排列(Arrangement)。特别地，当m=n时，这个排列被称作全排列(Permutation)
''' 1 2 3 4 假设从中取出3个数字 123 132 213 231 321 312 '''
#需求：从[1,2,3,4]4个数中随机取出3个数进行排列
mylist = list(itertools.permutations([1,2,3,4], 3)) print(mylist) print(len(mylist)) ''' 规律总结： 4 - 3 24 4 - 2 12 4 - 1 4 排列的可能性次数：n! / (n-m)! '''

import itertools #概念：从m个不同的元素中，任取n（n≤m）个元素为一组，叫作从m个不同元素中取出n个元素的进行组合
''' 1 2 3 4 5 中选4个数的组合方式有几种？ ''' mylist = list(itertools.combinations([1,2,3,4,5], 4)) print(mylist) print(len(mylist)) ''' 规律总结： m n 5 - 5 1 5 - 4 5 5 - 3 10 5 - 2 10 5！ 120/120(m-n)! 120/24(m-n)! 120/6(m-n)！ m!/(n!x(m-n)!) '''

import itertools ''' _ _ _ _ _ ''' mylist = list(itertools.product("0123456789QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm", repeat=6)) #可以尝试10，有可能电脑会卡住 #多线程也不行，电脑内存不够，咋处理都白搭 #print(mylist)
print(len(mylist))

import time import itertools #mylist = list(itertools.product("0123456789", repeat=10))
passwd = ("".join(x) for x in itertools.product("0123456789QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm", repeat=6)) #print(mylist) #print(len(mylist))
while True: #先直接实现，然后再添加异常
    try: str = next(passwd) time.sleep(0.5) print(str) except StopIteration as e: break

""" def checkQQ(str): #不管传入的str是否合法，我们假设合法 result = True #寻找条件推翻最初的假设 try: #判断是否是全数字 num = int(str) #判断位数 if len(str) >= 4 and len(str) <= 11: #判断是否以数字0开头 if str[0] == '0': result = False else: result = False except BaseException: result = False return result print(checkQQ("1490980463434"))

""" 分析： 1.全数字 2.位数：11位 3.开头只能是1 4.第二位可以为3，4，5，6，7，8 """
def checkPhone(str): result = True try: #判断是否是全数字
 int(str) #判断位数
        if len(str) == 11: #判断开头是否为1
            if str[0] == '1': #判断第二位的数字
                if str[1] != '3' and str[1] != '4' and str[1] != '5' and str[1] != '6' and str[1] != '7' and str[1] != '8': result = False else: result = False else: result = False except BaseException: result = False return result print(checkPhone("18501970795"))

. 匹配除换行符以外的任意字符 [0123456789] []是字符集合，表示匹配方括号中所包含的任意一个字符 [good] 匹配good中任意一个字符 [a-z] 匹配任意小写字母 [A-Z] 匹配任意大写字母 [0-9]            匹配任意数字，类似[0123456789] [0-9a-zA-Z] 匹配任意的数字和字母 [0-9a-zA-Z_] 匹配任意的数字、字母和下划线 [^good]          匹配除了good这几个字母以外的所有字符，中括号里的^称为脱字符，表示不匹配集合中的字符 [^0-9] 匹配所有的非数字字符 \d 匹配数字，效果同[0-9] \D 匹配非数字字符，效果同[^0-9] \w 匹配数字，字母和下划线,效果同[0-9a-zA-Z_] \W 匹配非数字，字母和下划线，效果同[^0-9a-zA-Z_] \s 匹配任意的空白符(空格，回车，换行，制表，换页)，效果同[ \r\n\t\f] \S 匹配任意的非空白符，效果同[^ \f\n\r\t]

print(re.findall("\d", "_sunck is 66a go8od man 3")) print(re.findall("[A-Z]","_sunck is 66a go8oD man 3")) print(re.findall("[a-z]","_sunck is 66a go8od man 3")) print(re.findall("[\S]","_sunck is 66a go8od man 3")) print(re.findall("[\W]","_sunck is 66a go8od man 3")) 输出： ['6', '6', '8', '3'] ['D'] ['s', 'u', 'n', 'c', 'k', 'i', 's', 'a', 'g', 'o', 'o', 'd', 'm', 'a', 'n'] ['_', 's', 'u', 'n', 'c', 'k', 'i', 's', '6', '6', 'a', 'g', 'o', '8', 'o', 'd', 'm', 'a', 'n', '3'] [' ', ' ', ' ', ' ', ' ']

^     行首匹配，和在[]里的^不是一个意思,"^"要写到字符串的前面 $ 行尾匹配,"$"要写到匹配的字符串后面 \A 匹配字符串的开始，它和^的区别是,\A只匹配整个字符串的开头，即使在re.M模式下也不会匹配其它行的行首 \Z 匹配字符串的结束，它和$的区别是,\Z只匹配整个字符串的结束，即使在re.M模式下也不会匹配它行的行尾 \b 匹配一个单词的边界，也就是值单词和空格间的位置 'er\b'可以匹配never,不能匹配nerve \B 匹配非单词边界

print(re.search("^sunck", "sunck is a good man")) print(re.search("man$", "sunck is a good man")) print(re.findall("^sunck", "sunck is a good man\nsunck is a nice man", re.M)) print(re.findall("\Asunck", "sunck is a good man\nsunck is a nice man", re.M)) print(re.findall("man$", "sunck is a good man\nsunck is a nice man", re.M)) print(re.findall("man\Z", "sunck is a good man\nsunck is a nice man", re.M)) print(re.search(r"er\b", "never")) print(re.search(r"er\b", "nerve")) print(re.search(r"er\B", "never")) print(re.search(r"er\B", "nerve")) 输出： <_sre.SRE_Match object; span=(0, 5), match='sunck'>
<_sre.SRE_Match object; span=(16, 19), match='man'> ['sunck', 'sunck'] ['sunck'] ['man', 'man'] ['man'] <_sre.SRE_Match object; span=(3, 5), match='er'> None None <_sre.SRE_Match object; span=(1, 3), match='er'>

#匹配qq邮箱，5~12位，第一位不为0
import re print(re.findall(r"^[1-9]\d{4,11}@qq\.com$","123456@qq.com")) print(re.findall(r"^[1-9]\d{4,11}@qq\.com$","0123456@qq.com")) print(re.findall(r"^[1-9]\d{4,11}@qq\.com$","123456@qq.co")) 1
2
3
4
5

说明：下方的x、y、z均为假设的普通字符,n、m（非负整数），不是正则表达式的元字符 (xyz) 匹配小括号内的xyz(作为一个整体去匹配) x? 匹配0个或者1个x(非贪婪匹配【尽可能少的匹配】) x*       匹配0个或者任意多个x（.* 表示匹配0个或者任意多个字符(换行符除外)）(贪婪匹配【尽可能多的匹配】) x+ 匹配至少一个x(贪婪匹配) x{n} 匹配确定的n个x（n是一个非负整数） x{n,} 匹配至少n个x x{n,m} 匹配至少n个最多m个x。注意：n <= m x|y      |表示或，匹配的是x或y

import re print(re.findall(r"a?", "aaa"))#非贪婪匹配(尽可能少的匹配)
print(re.findall(r"a*", "aaabaa"))#贪婪匹配(尽可能多的匹配)
print(re.findall(r"a+", "aaabaaaaaa"))#贪婪匹配(尽可能多的匹配)
print(re.findall(r"a{3}", "aaabaa")) print(re.findall(r"a{3,}", "aaaaabaaa"))#贪婪匹配(尽可能多的匹配)
print(re.findall(r"a{3,6}", "aaaabaaa")) print(re.findall(r"((s|S)unck)", "sunck--SuNck--Sunck")) #需求，提取sunck……man,
str = "sunck is a good man!sunck is a nice man!sunck is a very handsome man"
print(re.findall(r"sunck.*?man", str)) 输出： ['a', 'a', 'a', ''] ['aaa', '', 'aa', ''] ['aaa', 'aaaaaa'] ['aaa'] ['aaaaa', 'aaa'] ['aaaa', 'aaa'] [('sunck', 's'), ('Sunck', 'S')] ['sunck is a good man', 'sunck is a nice man', 'sunck is a very handsome man']

*?   +?   x?  最小匹配，通常都是尽可能多的匹配，可以使用这种解决贪婪匹配(?:x)    类似(xyz),但不表示一个组

# /* part1 */ /* part2 */
print(re.findall(r"/\*.*?\*/","/* part1 */ /* part2 */")) 输出： ['/* part1 */', '/* part2 */']

编译正则表达式模式，返回一个对象的模式。（可以把那些常用的正则表达式编译成正则表达式对象，这样做的目的是为了可以提高一点效率 格式： re.compile(pattern,flags=0) pattern: 编译时用的表达式字符串。 flags 编译标志位，用于修改正则表达式的匹配方式，如：是否区分大小写，多行匹配等 flags定义包括： re.I：使匹配对大小写不敏感 re.L：表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境 re.M：多行模式 re.S：’ . ’并且包括换行符在内的任意字符（注意：’ . ’不包括换行符） re.U： 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库 re.X VERBOSE 详细模式。该模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。 代码演示：

import re tt = "Tina is a good girl, she is cool, clever, and so on..." rr = re.compile(r'\w*oo\w*') print(rr.findall(tt))   #查找所有包含'oo'的单词

#执行结果如下： #['good', 'cool']

import re print(re.match('com','comwww.runcomoob').group()) print(re.match('com','Comwww.runcomoob',re.I).group()) print(re.match("com$","com122@qq.com")) print(re.match(r"^[1-9]\d{4,11}@qq\.com$","23344555@qq.com")) 输出： com Com None <_sre.SRE_Match object; span=(0, 15), match='23344555@qq.com'>

import re print(re.search('\dcom','www.4comrunoob.5com').group()) print(re.search("a+","aabaaaa")) print(re.findall("a+","aabaaaa")) 输出： 4com <_sre.SRE_Match object; span=(0, 2), match='aa'> ['aa', 'aaaa']

import re p = re.compile(r'\d+') print(p.findall('o1n2m3k4')) 输出： ['1', '2', '3', '4']

import re tt = "Tina is a good girl, she is cool, clever, and so on..." rr = re.compile(r'\w*oo\w*') print(rr.findall(tt)) 输出： ['good', 'cool']

import re iter = re.finditer(r'\d+','12 drumm44ers drumming, 11 ... 10 ...') for i in iter: print(i) print(i.group()) print(i.span()) 输出： <_sre.SRE_Match object; span=(0, 2), match='12'>
12 (0, 2) <_sre.SRE_Match object; span=(8, 10), match='44'>
44 (8, 10) <_sre.SRE_Match object; span=(24, 26), match='11'>
11 (24, 26) <_sre.SRE_Match object; span=(31, 33), match='10'>
10 (31, 33)

import re print(re.split('\d+','one1two2three3four4five5')) 输出： ['one', 'two', 'three', 'four', 'five', '']

import re string3 = '[12:23:90][12:90:87][23233][dsnernrev]'
print(re.split(r"\[|\]",string3)) 输出： ['', '12:23:90', '', '12:90:87', '', '23233', '', 'dsnernrev', '']

import re text = "Bob is a handsome boy, he is cool, clever, and so on..."
print(re.sub(r'\s+', '-', text)) 输出： Bob-is-a-handsome-boy,-he-is-cool,-clever,-and-so-on... #其中第二个参数是替换后的字符串；本例中为'-'

#第四个参数指替换个数。默认为0，表示每个匹配项都替换。

import re text = "JGood is a handsome boy, he is cool, clever, and so on..."
print(re.sub(r'\s+', lambda m:'['+m.group(0)+']', text,0)) 输出： JGood[ ]is[ ]a[ ]handsome[ ]boy,[ ]he[ ]is[ ]cool,[ ]clever,[ ]and[ ]so[ ]on...

import re print(re.subn('[1-2]','A','123456abcdef')) print(re.sub("g.t","have",'I get A, I got B ,I gut C')) print(re.subn("g.t","have",'I get A, I got B ,I gut C')) 输出： ('AA3456abcdef', 2) I have A, I have B ,I have C ('I have A, I have B ,I have C', 3)

import re a=re.search('[\d]',"abc3").group() print(a) p=re.match('[\d]',"abc3") print(p) b=re.findall('[\d]',"abc3") print(b) #执行结果： #3 #None #['3', '3']

import re a = re.findall(r"a(\d+?)",'a23b') print(a) b = re.findall(r"a(\d+)",'a23b') print(b) #执行结果： #['2'] #['23']

#这里需要注意的是如果前后均有限定条件的时候，就不存在什么贪婪模式了，非匹配模式失效。
 a = re.findall(r"a(\d+)b",'a3333b') print(a) b = re.findall(r"a(\d+?)b",'a3333b') print(b) #执行结果如下： #['3333'] #['3333']

print(re.split('a','1A1a2A3',re.I))#输出结果并未能区分大小写 #这是因为re.split(pattern，string，maxsplit,flags)默认是四个参数，当我们传入的三个参数的时候，系统会默认re.I是第三个参数，所以就没起作用。如果想让这里的re.I起作用，写成flags=re.I即可

#1、匹配电话号码[座机]
p = re.compile(r'\d{3}-\d{6}') print(p.findall('010-628888'))

#2、匹配IP
re.search(r"(([01]?\d?\d|2[0-4]\d|25[0-5])\.){3}([01]?\d?\d|2[0-4]\d|25[0-5]\.)","192.168.1.1")