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]) # 2
print(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)) #长度 10
print(max(ls)) #最大值 9
print(min(ls)) #最小值 1
print(sum(ls)) #求和48清空列表：：
ls=[1,2,3,4,5,6,7,8,9,3]
ls.clear() #清空
if ls: #所有的空都是False
print("今天周一")列表合并：
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) # True
print("html" not in ls) # False
print("html" in "hello,html") # True
# 5.列表相乘
print(ls * 2) # ['html', 'css', 'js', 'html', 'css', 'js']
# 6.检测列表元素：in关键字
# 说明：5大序列都可以使用in
ls = ["html", "css", "js"] # True
print("html" in ls) # False
print("html" not in ls) # True
print("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)
'''
html
css
js
php
python
java
'''
i = 0
while i < len(ls):
print(ls[i])
i += 1
'''
html
css
js
php
python
java
'''
# 9.列表推导式：快速生成列表
ls1 = [i for i in range(20)] # 0到19包括0，19
print(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 = True
if type(con) ==str:
# 是字符串
for i in con:
if not (i>='0' and i <='9'):
flag = False
break
# 判断flag
if 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 random
ls1=[]
for i in range(random.randint(10,30)):
a = ""
for j in range(random.randint(5,10)):
b=chr(random.randint(97,122))
a+=b
ls1.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]) #1
print(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')) # 2
print(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) # 1
print(b) # 2
print(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 random
ls1 = []
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 random
dt = {}
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']=20
print(dt) # {'id': 20, 'user': 'admin', 'pwd': '123456', 'sex': '女'}
# 删
del dt['user']
print(dt) # {'id': 20, 'pwd': '123456', 'sex': '女'}
# 6.遍历字典
import random
dt = {'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关键字
# 默认找的是key
dt = {'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 random
ls=[]
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 random
dt = {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']=20
print(dt) #{'id': 10}
# 二维：
# 1.浅拷贝
import copy
dt = {'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]=b
print(dt)更清晰的写法：
练习题：
制作键为0-9的数字，值为70-100之间的随机数字典，字典输出后，将字典中值高于80的数据过滤再次输出
import random
dt_={}
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]=v
print(dt_new)字典练习题：
统计随机列表（数字类）中元素出现的频度，统计结果以字典形式返回
import random
ls=[]
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 random
dt = {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 = 1
for m in dt.values(): #m就是各个元组
if k not in m:
flag = 0
break
if 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 random
ls = [1,2,3,4,5]
random.shuffle(ls) # 随机打乱
print(ls)
# 自己写:
ls =
length = len(ls)-1
for i in range(length):
index = random.randint(0,length-i)
tmp = ls[index]
ls[index] = ls[length-i]
ls[length-i] = tmp
print(ls)4.5字符串（重要）
str()是字符串函数
说明：程序对字符串的处理非常多，开发一个项目，基本上就是不断处理字符串,所以字符串很重要
字符串常见用法：
# 1.拼接
print('hello'+'world') # helloworld
# 2.长度:len()
# 说明： len()函数获取序列长度
dt = {'id':10,'user':'root'}
print(len(dt)) # 2
st = {1,2,3,4,2}
print(len(st)) # 4
sr = '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')) # hexxo
print(sr) # hello
# 注意方法的返回值
# 7.检索
# count() 检索出现多少次
# index() 检索首次的索引
sr = 'hello,python,php'
print(sr.count('p')) # 3
print(sr.index('p')) # 6(没有报错)
print(sr.find('p')) # 6(比较友好，没有返回-1)
# 8.大小写转换
# 场景：验证码
# ASCII大小写完全两个值
sr = 'hello'
print(sr.lower()) # hello
print(sr.upper()) # HELLO
# 9.去掉空格
# 场景：搜索
# 注意：空格也算字符
sr = ' he llo '
print(len(sr)) # 9
print(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()) # True
print('abc'.isalpha()) # True
print('abc1'.isalpha()) # False
print('123'.isdecimal()) # True
print('123六Ⅵ'.isdecimal()) # False
print('123六Ⅵ'.isnumeric()) # True
print('123六Ⅵa'.isnumeric()) # False
print('abc123六Ⅵ'.isalnum()) # True
print('abc123六Ⅵ!'.isalnum()) # False练习题：
# 去掉所有空格
sr = " he llo , wor ld! "
# 方法（1）
s = ''
for i in sr:
if i != ' ':
s += i
print(s) # hello,world!
# 方法（2）
s=''
for i in sr.strip().split(): # sr.strip(rm): rm为要深处的字符序列，rm为空时，默认删除空白符
s += i
print(s) # hello,world!
# 方法（3）
s = ''.join(sr.split(' ')) # join:用分隔符连接字符串中的元素,这里的''就是分隔符
print(s) # hello,world!
# 方法（4）
s = sr.replace(' ','')
print(s) # hello,world!
# 方法（5）
import re
s = 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=1
flag=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=0
break
i+=1
if flag==1:
print('合法')
else:
print('对不起，密码必须由数字、英文或下划线组成！')
else:print('对不起，大写字母开头')
else:
print('对不起，长度不合要求')
# 思路是利用ASCII码，用正常的逻辑代码可以实现，但很麻烦，麻烦就违背了编程的宗旨# 正则写法：
import re
uname = 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 re
sr = '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'
# 扩展需求：就要123xxx456xxx
res = 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 re
sr = '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 re
sr = '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 re
sr = 'hello,\d!'
#res = re.findall('\\\d',sr) # ['\\d']
res = re.findall(r'\\d',sr) # ['\\d']
print(res)案例：验证手机号是否合法，要求1开头，后面数字位3到9且长度刚好为有10位，
import re
tel = 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 re
ls = ['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)
'''
None
hello,python
None
None
hello
'''2）使用findall()方法进行匹配：在整个给定字符串中，搜索所有符合正则规则的字符串
3）使用search()方法进行匹配：在整个字符串中搜索第1个匹配的值（天然懒）
import re
sr = '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 re
sr = '恭喜13888889999用户喜中双色球1000w大奖！'
# 需求：将电话号码变成****
res = re.sub(r'1[123456789]\d{9}','****',sr) # 恭喜****用户喜中双色球1000w大奖！
print(res)5）使用split()分割字符串：把符合正则规则的字符串，分割出来（分割的规则，就是正则的规则）
import re
sr = '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 re
sr = "恭喜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 re
sr = "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)])
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
