python第四章——序列
第四章——序列4.1列表4.2元组4.3字典4.4集合4.5字符串（重要）4.6正则表达式第四章——序列
概念：序列指一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在索引位置的访问
说明：Python里常用的序列共有5种：列表、元组、字典、集合、字符串
说明：序列中元素的位置，叫做索引，索引值从0开始 ☆
4.1列表
说明：列表用[]表示
说明：list表示列表，且list()是列表函数
说明：列表中可以存放任意数据类型 ☆
ls = [1,2,3.14,"hello",True,[4,5,6]]print(ls)print(ls[1]) # 2print(ls[-1][-1]) # 6#列表元素操作—增删改ls.append("world") # 增del ls[0] #[2, 3.14, 'hello', True, [4, 5, 6]]ls[0]="我真帅" #['我真帅', 3.14, 'hello', True, [4, 5, 6], 'world']print(ls)
列表中常用方法：
ls=[1,2,3,4,5,6,7,8,9,3]print(ls.count(3)) #2(3出现次数)print(ls.index(3)) #2(3出现位置)print(ls.sort()) #None (排序，但是不会输出)print(ls)ls.sort(reverse=True) #关键字参数，默认是False(翻转)print(ls)#内置函数，不是列表的方法print(len(ls)) #长度 10print(max(ls)) #最大值 9print(min(ls)) #最小值 1print(sum(ls)) #求和48
清空列表：：
ls=[1,2,3,4,5,6,7,8,9,3]ls.clear() #清空if ls: #所有的空都是Falseprint("今天周一")
列表合并：
ls1 = [1,2,3]ls2 = [4,5,6]ls1.extend(ls2)print(ls1)
列表插入、移除、内容翻转操作：
ls=[1,2,3,4,5,6,250,7,8,9,3] # [1, 2, 3, 4, 5, 6]ls.insert(1,250) # [1, 250, 2, 3, 4, 5, 6, 250, 7, 8, 9, 3]print(ls)ls.pop() # 移除最后一位print(ls) # [1, 250, 2, 3, 4, 5, 6, 250, 7, 8, 9]ls.remove(250)print(ls) # [1, 2, 3, 4, 5, 6, 250, 7, 8, 9](移除了第一个250)ls=["php","java","html","css"]ls.reverse() #内容翻转print(ls) # ['css', 'html', 'java', 'php']
列表切片：
python中特有的写法
列表、元祖、字符串都支持切片，写法都相同
ls = ["php","js","python","linux","mysql","css","c++"]print(ls[2:4]) # ['python', 'linux'] (从2开始4结束输出2，3。不包括4)print(ls[2:6:2]) # ['python', 'mysql'] (从2开始，6结束步长为2输出2，4。不包括6)print(ls[2:]) # 默认切到最后 ['python', 'linux', 'mysql', 'css', 'c++']print(ls[:4]) # 默认从头开始切。从0开始4结束输出0，1，2，3。不包括4 ['php', 'js', 'python', 'linux']print(ls[::]) # ['php', 'js', 'python', 'linux', 'mysql', 'css', 'c++']\print(ls[::2]) # 步长为2切 ['php', 'python', 'mysql', 'c++']
列表进阶：
import random# 1.空列表ls = [] # 声明空列表if ls:print("hello")# 2.数值列表：内置函数list() range()ls = list(range(1, 10, 2))print(ls) # [1, 3, 5, 7, 9]# 3.随机列表：random模块ls = list(range(random.randint(1, 10), random.randint(50, 70)))print(ls)# 4.列表相加ls = ["html", "css", "js"]print("html" in ls) # Trueprint("html" not in ls) # Falseprint("html" in "hello,html") # True# 5.列表相乘print(ls * 2) # ['html', 'css', 'js', 'html', 'css', 'js']# 6.检测列表元素：in关键字# 说明：5大序列都可以使用inls = ["html", "css", "js"] # Trueprint("html" in ls) # Falseprint("html" not in ls) # Trueprint("html" in "hello,html")# 7.二维列表ls = [[1, 2, 3],[4, 5, 6],[7, 8, 9]]print(ls) # [[1, 2, 3], [4, 5, 6], [7, 8, 9]]print(ls[2][1]) # 8# 8.列表遍历：把所有元素依次取出ls = ["html", "css", "js", "php", "python", "java"]for i in ls:print(i)'''htmlcssjsphppythonjava'''i = 0while i < len(ls):print(ls[i])i += 1'''htmlcssjsphppythonjava'''# 9.列表推导式：快速生成列表ls1 = [i for i in range(20)] # 0到19包括0，19print(ls1)ls2 = [i * 2 for i in range(1, 10)] # [2, 4, 6, 8, 10, 12, 14, 16, 18]print(ls2)ls3 = [i * 2 for i in range(1, 100) if i < 20]# [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38]print(ls3)
案例：
过滤出小于5000的工资，以列表形式返回
salary = [3500,4800,2200,5000,89000,100000]
# 1)传统方法：ls=[]for sal in salary:if not sal<5000:ls.append(sal)print(ls) # [5000, 89000, 100000]# 2)推导式写法：ls=[sal for sal in salary if sal>=5000]print(ls) # [5000, 89000, 100000]
ls =[234,45,66,True,False,‘hello’,‘123’,‘456123aa’,‘Bbbbbbb’,‘sssss’,‘789’,‘BAC’,‘b’,‘ZZZ’,‘232a32’]
要求：
将ls中的纯数字字符串抽取出来，并倒序排列。
需要先了解几件事：
# 1.type()用法a = 'hello'print(type(a))# <class 'str'>print(type(a)==str)# True# 2.ASCII码# 判断单个字符是不是小写字母？# 1)传统写法code = 'x'num = ord(code)if num <= 122 and num >= 97:print('小写字母')# 2)直接判断if code >= 'a' and code <='z':print('小写字母')# 3)直接使用方法判断if code.islower():print('小写字母')
传统方法：
# 要求：将ls中的纯数字字符串抽取出来，并倒序排列。ls = [234,45,66,True,False,'hello','123','456123aa','Bbbbbbb','sssss','789','BAC','b','ZZZ','232a32']ls_new = []for con in ls:# 1.方法验证# if type(con) == str and con.isdigit():# print(con)# 123# 789# 2.ASCII码验证flag = Trueif type(con) ==str:# 是字符串for i in con:if not (i>='0' and i <='9'):flag = Falsebreak# 判断flagif flag:ls_new.append(con)ls_new.sort(reverse=True)print(ls_new) # ['789', '123']
其他方法：
# 要求：将ls中的纯数字字符串抽取出来，并倒序排列。ls = [234,45,66,True,False,'hello','123','456123aa','Bbbbbbb','sssss','789','BAC','b','ZZZ','232a32']# 其他方法：all()内置函数# mysql中any()满足任意一个，all()必须全部满足ls_new = [i for i in ls if type(i) == str and all((j >='0' and j <= '9')for j in i)]print(ls_new) # ['123', '789']
作业：
制作长度为5-10的、个数为10-30的随机小写字母字符串，
以列表形式返回，输出后去掉长度小于8的，
并将符合要求的字符串随机抽取3个，最后从小到大排列输出
import randomls1=[]for i in range(random.randint(10,30)):a = ""for j in range(random.randint(5,10)):b=chr(random.randint(97,122))a+=bls1.append(a)#print(ls1)ls2=[]for k in ls1:if len(k)>=8:ls2.append(k)#print(ls2)ls3=[]for x in range(0,3):ls3.append(random.choice(ls2))ls3.sort()print(ls3)
步骤更清晰版：
4.2元组
英文：tuple
说明：列表是可变的，元组不可变
说明：元组用小括号( )，列表用中括号[ ]
Is = ["cat","dog","tiger",1024]It = tuple(Is)#将列表类型变成元组类型，保护数据print(It)#('cat', 'dog', 'tiger', 1024)
元组也可以切片
元组里有列表的话，列表内部是可变的
元组切片：
tp = (1,2,3.14, True,['python','java'], 'hello' ,(1,2,3))print(tp)print(tp[0]) #1print(tp[4]) # ['python', 'java']print(tp[4:]) # (['python', 'java'], 'hello', (1, 2, 3))
注意：当元组中，只有一个元素时，需要用逗号分隔，目的是区分于字符串
tp = (1,2,3,) #习惯print(tp) # (1, 2, 3)#坑tp1 = ('hello')print(type(tp1)) # <class 'str'>tp2 = ('hello',)print(type(tp2)) # <class 'tuple'>
元组用法：
# 1.空元组tp = ()if tp:print('hello')# 2.数值元组tp = tuple(range(10))print(tp) # (01,23,4,5,6,7,8, 9)# 3.元组加法乘法tp1 = (1, 2, 3)tp2 = (4, 5, 6)print(tp1 + tp2) # (1,2,3,4,5,6)print(tp1 * 2) # (1,2,3,1,2,3)# 4.元组删除# 元组中的删除，是删除整个元组#tp = ('hello', 'world')#del tp#print(tp) # tp変量不可用# 5.常用方法tp = ('hello', 'world', 'html', 'hello', 'java', 'html', 'css', 'js', 'linux', 'html')print(tp.count('hello')) # 2print(tp.index('html')) # 2 # 写tp里的元素时要注意空格，否则元素不一样print(tp.index('html', 4, 8)) # 5 可以设置范围# 6.max() min() sum() len()# 7.元组推导式tp = (i for i in range(1, 20) if i > 10)print(tp) # <generator object <genexpr> at 0x000002258A4DD8E0> generator 生成器# <>表示対象print(tuple(tp)) # (11, 12, 13, 14, 15, 16, 17, 18, 19) .# 8.元组拆包(自动映射)a, b, c = (1, 2, 3)print(a) # 1print(b) # 2print(c) # 3# 补充：# 列表与元组转换:ls =[1,2,3]tp = tuple(ls)print(tp) # (1,2,3)tp = (4,5,6)ls = list(tp)print(ls) # [4,5,6]
练习题：
制作元素由元组组成的列表，并以列表形式输出所有元组中出现频率最高的元素
要求：元组中的元素个数随机，元组中元素数值随机，列表中的元素个数随机
import randomls1 = []ls2 = []for i in range(1, 5):ls = []for j in range(random.randint(6, 10)):ls.append(random.randint(11, 15))ls1.append(tuple(ls))print(ls1)ls2 = [int(x) for item in ls1 for x in item]print(ls2)con = [0 for i in range(20)]for k in ls2:con[k] += 1# print(con)a = max(con)ls3 = []for x in range(20):if a == con[x]:ls3.append(x)print(ls3)
步骤更清晰版：
4.3字典
说明：dict()是字典函数
说明：字典与列表类似，都是可变序列，但字典是无序的，而列表和元组都是有序的 ☆
说明：有序意味着有索引值的概念 ☆
说明：字典保存的内容是键值对的形式 ☆
键值对：类似新华字典中的拼音和汉字，拼音就是key，汉字就是value
特点：键是唯一的，值可以重复 ☆
总结：列表用中括号[ ]，元组用小括号( )，字典用花括号{ }
# 字典# 类似JSON格式（爬虫的时候会涉及）# JSON和XML两个数据格式(JSON网络传输、XML配置文件)dt = {'id':10,'username':'root','password':'123456','age':1,'sex':1, #值可以重复'id':20#20会把10覆盖（键不能重复）}print(dt) #{'id': 20, 'username': 'root', 'password': '123456', 'age': 1, 'sex': 1}
常见用法：
# 1.空字典import randomdt = {}if dt:print('hello')# 2.映射函数zip()ls1 = [1,2,3]ls2 = ['a','b','c']print(dict(zip(ls1,ls2))) # {1: 'a', 2: 'b', 3: 'c'}print(dict(zip(ls2,ls1))) # {'a': 1, 'b': 2, 'c': 3}# zip扩展：ls=['hello','php','js']tp=(1,2,3)for i,j in zip(ls,tp):print(i,j)#hello 1#php 2#js 3# 3.关键字参数dt = dict(id=10,user='admin',pwd='123456')print(dt) # {'id': 10, 'user': 'admin', 'pwd': '123456'}# 4.清空字典if dt.clear():print('hello')# 5.增删改查dt = {'id':10,'user':'admin','pwd':'123456'}# 查print(dt['id']) # 10(如果key不存在，报异常）print(dt.get('pwd')) # 123456(如果key不存在，返回None）# 增：键不存在dt['sex']='女'# 改：键存在dt['id']=20print(dt) # {'id': 20, 'user': 'admin', 'pwd': '123456', 'sex': '女'}# 删del dt['user']print(dt) # {'id': 20, 'pwd': '123456', 'sex': '女'}# 6.遍历字典import randomdt = {'id':10,'user':'admin','pwd':'123456'}for i in dt:print(i) #键print(dt[i]) #值print('==========')for k,v in dt.items():print(k,v)print('==========')for key in dt.keys():print(key)print('==========')for value in dt.values():print(value)# 7.字典推导式（少）dt = {i:random.randint(1,10) for i in range(10)}print(dt)# 8.in关键字# 默认找的是keydt = {'id':10,'user':'admin','pwd':'123456'}if 'id' in dt:print('hello') #hello
字典方法：
# 1.字典删除dt = {'id':10,'user':'root','pwd':'123456','address':'哈尔滨'}dt.pop('id')# 删除print(dt) # {'user': 'root', 'pwd': '123456', 'address': '哈尔滨'}# 2.字典生成# 说明：fromkeys第一个参数一定是序列，第二个参数是默认值dt = {}print(dt.fromkeys([1,2,3])) # {1: None, 2: None, 3: None}print(dt.fromkeys(['id','user','pwd'],'hello')) # {'id': 'hello', 'user': 'hello', 'pwd': 'hello'}print(dt.fromkeys((4,5,6),'xxx')) # {4: 'xxx', 5: 'xxx', 6: 'xxx'}print(dt.fromkeys('hello')) # 键不能重复 {'h': None, 'e': None, 'l': None, 'o': None}
两种等价的随机字典生成方式：
第一种：
import randomls=[]for i in range(1,21):ls.append(i)print(ls)ls2 = []for j in range(1,21):ls2.append(random.randint(50,100))dt={ls[m]:ls2[m] for m in range(0,20)}print(dt)
第二种：
import randomdt = {i:random.randint(50,100) for i in range(1,20)}print(dt)
# 3.移除最后一项dt = {'id':10,'user':'root','pwd':'123456','address':'哈尔滨'}dt.popitem()print(dt) # {'id': 10, 'user': 'root', 'pwd': '123456'}# 4.设置默认值dt = {'id':10,'user':'root','pwd':'123456','address':'哈尔滨'}dt.setdefault('sex','男') #如果没有，就是添加dt.setdefault('user','hello') #如果有，就不设置print(dt)# 5.更新字典dt = {'id':10,'user':'root','pwd':'123456','address':'哈尔滨'}dt.update({'id':20})dt.update({'user':'hello','age':10})dt.update([('pwd','666'),('user','admin'),('sex','男')])print(dt)# 6.深浅拷贝# copy()方法（二维以上）# 浅拷贝：改变拷贝的内容时，原先内容也会被修改（类似快捷方式，指向的还是原先位置）# 深拷贝：改变拷贝的内容时，原先内容不会被修改（就是完全复制出来一份）# 一维：（默认深拷贝）dt = {'id':10}dt_new = dt.copy()dt_new['id']=20print(dt) #{'id': 10}# 二维：# 1.浅拷贝import copydt = {'con':{'user':'hello'}}dt_new=dt.copy()dt_new['con']['user']='admin'print(dt) # {'con': {'user': 'admin'}} 浅拷贝# 2.深拷贝dt = {'con':{'user':'hello'}}dt_new=copy.deepcopy(dt)dt_new['con']['user']='admin'print(dt) # {'con': {'user': 'hello'}} 深拷贝
字典方法：
JSON数据格式
作用：用作网络数据传输 web网页
结构：BS机构软件（WEB端）
浏览器->服务器 发送请求Request
服务器->浏览器 接收响应Request(JSON数据)
格式：类似字典，JSON格式非常严格，必须使用双引号
注意：JSON文件中不允许写注释，多余的空行也不要有，但纯数字可以不加引号
import json# json.loads() 将json数据格式的字符串转成字典（方便操作）# json.dumps() 将字典转成json数据格式的字符串sr = '{"id":10,"user":"root","pwd":"123456","con":"hello"}'dt = json.loads(sr)print(dt) # {'id': 10, 'user': 'root', 'pwd': '123456', 'con': 'hello'}print(type(dt))# <class 'dict'>print(dt['pwd']) # 123456# 需求：把整个字典作为数据进行返回（字符串）dt = {'a':10,'b':20,'c':30}sr = json.dumps(dt)print(sr) # {"a": 10, "b": 20, "c": 30}print(type(sr)) # <class 'str'># 扩展：多层res = '[{"id":10,"user":"hello"},{"pwd":["php","html"]},{"sex":"男","con":{"a":10,"b":20}}]'ls = json.loads(res)print(ls)print(ls[1]['pwd'][1]) # html
练习题
# 1.找到公告的键，以列表形式返回 ['a','c']# 2.找到公告的值，以列表形式返回 [250，20，30]# 3.找到公告的键值，以字典形式返回 [{'c':20},{'res':123}]dt1 = {'a':10,'b':20,'c':30,'d':250}dt2 = {'a':250,'c':30,'e':20,'f':70}dt3 = {'x':250,'y':255,'a':20,'c':30}ls1=[]ls2=[]ls3=[]dt={}dt4={}for i in dt1.keys():if i in dt2.keys() and i in dt2.keys():ls1.append(i)print(ls1)for j in dt1.values():if j in dt2.values() and j in dt2.values():ls2.append(j)print(ls2)for a ,b in dt1.items():if a in dt2.keys() and a in dt2.keys():if dt2[a]==b and dt3[a]==b:dt[a]=bprint(dt)
更清晰的写法：
练习题：
制作键为0-9的数字，值为70-100之间的随机数字典，字典输出后，将字典中值高于80的数据过滤再次输出
import randomdt_={}dt=dt_.fromkeys([i for i in range(10)])for key in dt.keys():dt[key]=random.randint(70,100)print(dt) dt_new ={}for k,v in dt.items():if v<=80:dt_new[k]=vprint(dt_new)
字典练习题：
统计随机列表（数字类）中元素出现的频度，统计结果以字典形式返回
import randomls=[]for i in range(random.randint(10,20)): # 或者用ls=[random.randint(10,20) for i in range(10)] 代替for循环j=random.randint(5,10)ls.append(j)print(ls)dt={}for k in ls:if k not in dt: #为了高效，大大减少判断次数dt[k]=ls.count(k)print(dt)
4.4集合
集合保存不重复的元素，所以主要用途就是去重
集合不可存放列表、字典、集合，只能放元组及其他基本类型
集合是无序、可变的序列
st = {41,2,22,3,1,2}print(st)
总结：
1.无序：存储和输出的顺序不一定一致
2.去重：自动去掉重复的元素
集合常见用法：
# 1.空集合st={}print(type(st))# <class 'dict'>st = set()print(type(st))# <class 'set'>if st:print('hello')# 2.相互转换#目的就是去重# 列表、元组、字符串，都可以转集合 ls = [1,2,2,3,3,3,2,1,2]ls = list(set(ls))print(ls) # [1, 2, 3]# 3.集合添加st = {1,2,3,4}st.add('hello')# 添加一个整体st.update('world')# 拆分st.update([123,456]) # 添加多个print(st) # {1, 2, 3, 4, 'l', 456, 'w', 'hello', 'o', 'r', 123, 'd'}# 4.集合删除st = {1,2,3,4}st.remove(2)print(st) # {1, 3, 4}# 5.集合清空st = {1,2,3,4}st.clear()print(st) # set()# 6.集合遍历st = {1,2,3,4}for i in st:print(i)# 7.特有属性# 交集&、并集|、差集-# 前提：一定是两个集合之间st1 = {'php','js','python','css','html','linux','java'}st2 = {'php','c++','R','Go','html','mysql','shell'}print(st1 & st2) # 交集 {'html', 'php'}print(st1 | st2) # 并集 {'shell', 'php', 'linux', 'java', 'css', 'mysql', 'js', 'Go', 'R', 'c++', 'html', 'python'}print(st1 - st2) # 差集 {'java', 'js', 'python', 'css', 'linux'}print(st2 - st1) # 差集 {'shell', 'R', 'mysql', 'Go', 'c++'}
总结：列表、元组、字典、集合的区别：
练习题：
# 制作一个字典，键为26个大写字母，值为随机数值的元组，# 并找出所有元组共有的数值，以列表形式返回import randomdt = {chr(key):tuple(random.randint(5,10)for i in range(15,35))for key in range (65,91)}print(dt)# ①不用集合st=set(dt['A'])#del dt['A'] #提升性能ls1 = []for k in st: #集合可以遍历flag = 1for m in dt.values():#m就是各个元组if k not in m:flag = 0breakif flag:ls1.append(k)print(ls1)# ②使用集合st = set(dt['A'])del dt['A']#print(st,end='****')for n in dt.values():#print(set(n))st = st & set(n)print(list(st))
练习题：
# 随机打乱数组import randomls = [1,2,3,4,5]random.shuffle(ls) # 随机打乱print(ls)# 自己写:ls = length = len(ls)-1for i in range(length):index = random.randint(0,length-i)tmp = ls[index]ls[index] = ls[length-i]ls[length-i] = tmpprint(ls)
4.5字符串（重要）
str()是字符串函数
说明：程序对字符串的处理非常多，开发一个项目，基本上就是不断处理字符串,所以字符串很重要
字符串常见用法：
# 1.拼接print('hello'+'world') # helloworld# 2.长度:len()# 说明： len()函数获取序列长度dt = {'id':10,'user':'root'}print(len(dt)) # 2st = {1,2,3,4,2}print(len(st)) # 4sr = 'hello'print(len(sr)) # 5# 3.编码：utf-8/gbk# 场景：统计字符串长度（中文）sr = 'hello,老师真帅。'print(len(sr)) # 11(默认一个中文算一个长度)sr_encode = sr.encode('utf-8')print(sr_encode) # b'hello,\xe8\x80\x81\xe5\xb8\x88\xe7\x9c\x9f\xe5\xb8\x85\xe3\x80\x82'# 解码：decode()print(sr_encode.decode('utf-8')) # hello,老师真帅。print(len(sr.encode('utf-8'))) # 编码 21 （一个中文算3个长度，句号也算）print(len(sr.encode('gbk'))) # 编码 16 （一个中文算两个长度）# 4.截取：# 切片：索引# 列表、元组、字符串都可以切片（集合、字典是无序的，没有索引值，所以无法切片）sr = 'hello,python'print(sr)print(sr[6:]) # python# 5.分割：sr = 'php,html,css,java,python,c'ls = sr.split(',')print(ls) # ['php', 'html', 'css', 'java', 'python', 'c']# 6.替换sr = 'hello'print(sr.replace('ll','xx')) # hexxoprint(sr) # hello# 注意方法的返回值# 7.检索# count() 检索出现多少次# index() 检索首次的索引sr = 'hello,python,php'print(sr.count('p')) # 3print(sr.index('p')) # 6(没有报错)print(sr.find('p')) # 6(比较友好，没有返回-1)# 8.大小写转换# 场景：验证码# ASCII大小写完全两个值sr = 'hello'print(sr.lower()) # helloprint(sr.upper()) # HELLO# 9.去掉空格# 场景：搜索# 注意：空格也算字符sr = ' he llo 'print(len(sr)) # 9print(sr.strip()) # he llo 去掉左右两边的空格（空白：换行符也可以去掉）# 注意：中间空格无法去掉sr = 'xhello'print(sr.strip('x')) # hello# 10.格式化# 1)print('f')# 2)format()# 3)拼接 +sr = 'hello {},操作真{}~'print(sr.format('帅哥',6)) # hello 帅哥,操作真6~sr = 'hello,%s,你真%s~'print(sr % ('帅哥','帅')) # hello,帅哥,你真帅~
专题用法：
# 1.关于转换# 字符串->列表# 字符串->元组# 字符串->集合# 字符串->字典 (不行)sr = 'hello'print(list(sr))# ['h', 'e', 'l', 'l', 'o']print(tuple(sr)) # ('h', 'e', 'l', 'l', 'o')print(set(sr))# {'h', 'o', 'e', 'l'}# 2. join()方法# 写法：str.join(序列)# 前提：序列中的元素类型必须是字符串# ls = [1,2,3]ls = ['python','css','java','html','c++']sr = '/'.join(ls)print(type(sr))# <class 'str'>print(sr)# python/css/java/html/c++# 3.判断纯字符串中的类型sr = '123'print(sr.isdigit())# 纯数字# 4.其他方法sr = 'hello'print(sr.capitalize()) # Hello# 说明：字符串对象里封装了很多方法，如果有些方法不知道，可以用其他逻辑方法进行处理# 但更多记住这些内置的方法，就能够提升编程效率
is开头
1、isspace判断指定的字符串是否全部由空白字符组成。
2、isalpha判断指定的字符串是否全部由字母组成。
3、isdecimal。
判断指定字符串是否全部由十进制数字组成。
4、Isnumeric。
判断指定的字符串是否全部由数字组成。
5、Isalnum。
判断指定的字符串是否全部由字母和数字组成。
print('\t \r\n'.isspace()) # Trueprint('abc'.isalpha()) # Trueprint('abc1'.isalpha()) # Falseprint('123'.isdecimal()) # Trueprint('123六Ⅵ'.isdecimal())# Falseprint('123六Ⅵ'.isnumeric())# Trueprint('123六Ⅵa'.isnumeric()) # Falseprint('abc123六Ⅵ'.isalnum()) # Trueprint('abc123六Ⅵ!'.isalnum()) # False
练习题：
# 去掉所有空格sr = " he llo , wor ld! "# 方法（1）s = ''for i in sr:if i != ' ':s += iprint(s) # hello,world!# 方法（2）s=''for i in sr.strip().split(): # sr.strip(rm): rm为要深处的字符序列，rm为空时，默认删除空白符s += iprint(s) # hello,world!# 方法（3）s = ''.join(sr.split(' ')) # join:用分隔符连接字符串中的元素,这里的''就是分隔符print(s) # hello,world!# 方法（4）s = sr.replace(' ','')print(s) # hello,world!# 方法（5）import res = re.sub(' ','',sr) # 用sub函数来查询替换print(s) # hello,world!
练习题：
# 将字符串改为字典，要求键为选项，值为内容，# 并按字母顺序排序。# 法一：sr = "B.JavaWeb,D.PythonWeb,A.Java大数据,C.Python人工智能"print({i[0]:i[2:] for i in sorted(sr.split(','))})# 法二：ls = sr.split(',')ls.sort()ls_new = []dt={}for i in ls:ls_new.append(tuple(i.split('.')))dt.update(ls_new)print(dt)
4.6正则表达式
说明：正则是专门用来处理字符串的一个规则
为什么要用正则：
需求1：判断用户名长度为[8,16]位
uname = input('请输入用户名:')# 验证合法性：if len(uname)>=8 and len(uname)<=16:print('合法')else:print('非法')# 似乎没毛病
需求2：判断密码长度为[8,16]位，字符只能是英文或数字或下划线，且要大写字母开头 （逻辑处理）：
username = input('用户名：')length = len(username)if length>=8 and length<=16: # 密码长度为[8,16]位code = ord(username[0])if code>=65 and code<=90: # 大写字母开头i=1flag=1 # 设置标志位while i <=length-1:z = ord(username[i])if not((z>=48 and z<=57) or (z>=65 and z<=90) or (z>=97 and z<=122) or z==95): # 字符只能是数字或英文或下划线flag=0breaki+=1if flag==1:print('合法')else:print('对不起，密码必须由数字、英文或下划线组成！')else:print('对不起，大写字母开头')else:print('对不起，长度不合要求')# 思路是利用ASCII码，用正常的逻辑代码可以实现，但很麻烦，麻烦就违背了编程的宗旨
# 正则写法：
import reuname = input('请输入用户名：')if re.match(r'^[A-Z][A-Za-z0-9_]{7,15}$',uname):print('合法')else:print('非法')
re.match：尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match就返回none (只匹配字符串的开始)
re.findall：在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空
1.常用正则符号（输入法要切成英文）：
^开头：Shift+6
$结尾：Shift+4
情景1：匹配用户输入的内容是否合法：需要开头结尾
情景2：对内容进行部分匹配：不需要用开头结尾
.表示任意一个字符：除了换行\r\n（英文句号）
+表示1个或多个字符（至少1个）【向左修饰原则】
？表示0个或1个字符【向左修饰原则】
*表示0个或多个字符【向左修饰原则】
例：
import resr = 'hello,world'# res = re.findall(r'l',sr) # ['l', 'l', 'l']res = re.findall(r'l+',sr) # ['ll', 'l']# res = re.findall(r'l?',sr) # ['', '', 'l', 'l', '', '', '', '', '', 'l', '', '']# res = re.findall(r'l*',sr) # ['', '', 'll', '', '', '', '', '', 'l', '', '']print(res)
import re#sr = 'hello,world'# res = re.findall(r'hel',sr) # ['hel']#sr = 'hxllo,world'# res = re.findall(r'h.l',sr) # ['hxl']# res = re.findall(r'h.+l',sr) # ['hxllo,worl'] 默认贪婪匹配（尽可能多匹配）# res = re.findall(r'h.+?l',sr) # ['hxl'] 默认懒惰匹配（尽可能少匹配）sr = 'h123xxx456xxxllo,world'# 扩展需求：就要123xxx456xxxres = re.findall(r'h(.*?)l',sr) # ['123xxx456xxx']# res = re.findall(r'h(.*)l',sr) ['123xxx456xxxllo,wor']print(res)
.*?表示非贪心算法，表示要精确的配对；加括号表示只获取() 之间的数据
.*表示贪心算法，表示要尽可能多的匹配
花括号{}：
{n}表示重复n次: {6}表示重复6次【向左修饰原则】
{n,}表示至少重复n次【向左修饰原则】
{n,m}表示重复n-m次：闭区间【向左修饰原则】
import re#sr = 'hello,world'# res = re.findall(r'l+',sr)#['ll', 'l']# res = re.findall(r'l{2}',sr) # ['ll']#sr = 'hello,world,helllo'#res = re.findall(r'l{2}',sr) # ['ll', 'll']#print(res)sr = 'hello,world,hellllo'#res = re.findall(r'l{2}',sr) # ['ll', 'll', 'll']#res = re.findall(r'l{2,}',sr) # ['ll', 'llll']res = re.findall(r'l{1,3}',sr) # ['ll', 'l', 'lll', 'l']print(res)
中括号[]：
[xyz]表示取x或取y或取z：只取单个字符
[0-9]表示取任意一个数字
[a-z]表示取任意一个小写字母
[A-Z]表示取任意一个大写字母
[^xyz]表示取反，也就是除了x或y或z取其他字符
[\u4e00-\u9fa5]表示任意一个汉字，有6w+个
import re#sr = 'hello,world!'# res = re.findall(r'[helo]',sr) # ['h', 'e', 'l', 'l', 'o', 'o', 'l']# res = re.findall(r'[helo]+',sr)# ['hello', 'o', 'l']# res = re.findall(r'[a-z]+',sr)# ['hello', 'world']sr = 'hello,world!帅哥，美女！123,456!'# res = re.findall(r'[0-9]+',sr) # ['123', '456']res = re.findall(r'[\u4e00-\u9fa5]+',sr) # ['帅哥', '美女']print(res)
|表示选择，或者关系：
import resr = 'hello,xyz!world!'# res = re.findall(r'[xyz]',sr) # ['x', 'y', 'z']res = re.findall(r'hello|xyz',sr) # ['hello', 'xyz']print(res)
反斜线：
正斜线：/
\d 匹配数字：相当于0-9(重要)
\D 匹配非数字
\w 匹配英文、数字、下划线、汉字（重要）
\W 匹配非英文、数字、下划线、汉字
\s 匹配空白符：空格、换行（文件操作IO）
\S匹配非空白（不包括换行）
import resr = 'hello,123,帅哥！~'# 匹配英文、数字、中文res = re.findall(r'\w+',sr)# ['hello', '123', '帅哥']# 匹配纯数字res2 = re.findall(r'\d+',sr) # ['123']res3 = re.findall(r'[A-Za-z]+',sr)print(res3)# ['hello']
\表示转义符：把带有特殊意义的字符，转成普通字符
r 表示原生字符串：写在规则前面（结论：规则前要加r）
r可以理解为固定写法：有的需要转义，有的不需要，就直接写r就全不要了
import resr = 'hello,\d!'#res = re.findall('\\\d',sr) # ['\\d']res = re.findall(r'\\d',sr) # ['\\d']print(res)
案例：验证手机号是否合法，要求1开头，后面数字位3到9且长度刚好为有10位，
import retel = input('请输入手机号：')if re.match(r'^1[3456789]\d{9}$',tel):print('合法')else:print('非法')
re模块下五种常用方法：match/findall/search/split/sub
1）re.match尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match就返回none (只匹配字符串的开始)
import rels = ['Hello,world','hello,python','hi,hello','123,hello','hello']pattern = r'hello.*'for i in ls:res = re.match(pattern,i)if res:print(res.group()) # match对象获取需要更进一步,不能直接print(res)否则会出现<_sre.SRE_Match object; span=(0, 12), match='hello,python'>这样else:print(res)'''Nonehello,pythonNoneNonehello'''
2）使用findall()方法进行匹配：在整个给定字符串中，搜索所有符合正则规则的字符串
3）使用search()方法进行匹配：在整个字符串中搜索第1个匹配的值（天然懒）
import resr = 'hello,py_css,py_html,py_python'pattern = r'py_[a-z]+'res = re.search(pattern,sr)print(res)# <_sre.SRE_Match object; span=(6, 12), match='py_css'>print(res.group()) # py_css search对象获取需要更进一步
4）使用sub()替换字符串：把符合正则规则的字符串，进行替换成指定的字符串
import resr = '恭喜13888889999用户喜中双色球1000w大奖！'# 需求：将电话号码变成****res = re.sub(r'1[123456789]\d{9}','****',sr) # 恭喜****用户喜中双色球1000w大奖！print(res)
5）使用split()分割字符串：把符合正则规则的字符串，分割出来（分割的规则，就是正则的规则）
import resr = 'php!python@css#html$js%sql^c++*java,mysql8'# 需求：获取所有语言名称res = re.split(r'[!@#&%^*$,]',sr)print(res)# ['php', 'python', 'css', 'html', 'js', 'sql', 'c++', 'java', 'mysql8']
import resr = "恭喜13877779999喜中双色球1000w大奖，15788001122用户也中了。"res = re.sub(r'(1[0123456789]\d{1})(\d{4})(\d{4})',r'\1****\3',sr) #\1表示第1个分组的内容，\3表示第3个分组的内容print(res) # 恭喜138****9999喜中双色球1000w大奖，157****1122用户也中了。
# 2.小练习import resr = "12.一代天骄成吉思汗，只识弯弓射大雕。9.须晴日，看红装素裹，分外妖娆。2.千里冰封，5.惟余莽莽；3.万里雪飘，4.望长城内外，6.大河上下，1.北国风光，7.顿失滔滔。8.山舞银蛇，原驰蜡象，欲与天公试比高。11.惜秦皇汉武，略输文采；唐宗宋祖，稍逊风骚。13.俱往矣，数风流人物，还看今朝。10.江山如此多娇，引无数英雄竞折腰。"# res1 = re.findall(r'\d+[^\d]+',sr) res1 = re.findall(r'\d+\D+',sr)print(res1)dt = {}for i in res1:res2 = i.split('.')dt[res2[0]] = res2[1]print(dt)for j in range(len(dt)):print(dt[str(j+1)])
如果觉得《【python第四章——序列（列表 元组 字典 集合 字符串 正则）】》对你有帮助，请点赞、收藏，并留下你的观点哦！
