Python---元组---字典---集合

4.3. 元组

        4.3.1. 概念：

           在大型的商业网站或游戏设计中，列表是一种非常重要的数据类型，因为其记录了各种等级客 户、游戏角色，列表数据可以随时变动更新， python还提供另一组数据类型成为元组

（tuple），这种数据类型结构与列表完全相同，但 最大差异是元素的值和个数不可更改，又 称不可变列表

        元组（tuple ）使用圆括号（）将一组不可变的 数据序列组合起来形成序列

4.3.2. 元组中不允许的操作：

        修改、新增元素

        删除元素（但可以删除整个元组）

        所有会对元组内部元素发生修改动作的方法。例

        如，元组没有remove ， append ， pop 等方法

4.3.3. 元组操作

        创建格式：tuplename=(element1 ,  element2 , ……， elementn) ， 元组中元素个 数无限制，类型可以都不相同，例：

num1 = (2, 3, 4, 5, 6)
num2 = (1,)  # 创建一个元素的元组，重要
num3 = (1)  # 不是元祖，只是数值为1的对象
num4 = ()  # 空元组
num5 = tuple(range(0, 20, 2))  # 使用
# tuple()函数创建数值元祖，当前为偶数元组
string1 = ('china', 'hello', 'world')
string2 = (82, 'python', [1, 2, 3, 4])

string3 = 'python', '你好', '人生苦短'
# (注意：圆括号可以省略)

删除整个元组： del tuplename

元组是不可变序列，不支持单个元素修改，但可以重新整体赋值修改

tup1 = (12, 34.56)
tup2 = ('abc','xyz')
tup1[0] = 100 # 报错
tup1 = (23, 45, 78) # 整体重新赋值
tup3 = tup1 + tup2

元组只保证它的一级子元素不可变，对于嵌套的 元素内部，不保证不可变！

tup = ('a','b', ['A','B'])
tup[2][0] ='X'
tup[2][1] ='Y'
print(tup) # 显示：('a','b', ['X','Y'])

元组连接时必须维持元组，不能字符串或列表等

tup1 = (1, 2, 3)
list1 = [4, 5, 6]
tup2 = tup1 + list1 # 报错
tup3 = tup1 +'china' # 报错

元组连接只有一个元素的元组时，必须加逗号

tup1 = (1, 2, 3)
tup2 = tup1 + (4) # 报错 改为
tup2=tup1+(4,)

元组的读取 : 定义元组时使用（），若要读取元组 内容还是和列表一样使用 [ ] 配合索引完成读取

num1 = (1, 2, 3, 4, 5)
str1 = ('apple','orange')
print(num1[0], str1[1])

元组切片 : 与列表切片操作方式相同

import random

tp1 = tuple(random.sample(range(30),10))
print(tp1)
print(tp1[1:3])
print(tp1[:4])
print(tp1[5:])
print(tp1[-2:])
print(tp1[-3:3:-1])
print(tp1[0:5:3])

元组方法与函数：列表上会更改内容的函数都无 法使用

# 下列程序报错
 tp1 = (123,'hello','asckii')
num = tp1.pop() # pop() 函数用于随机移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

tp1 = (123,'hello','asckii')
print(len(tp1)) # len()正常使用

列表与元组数据互换

        list（）：转为列表

        tuple（）：装转为元组

tp1 = (123,'hello','999', 35.6)
list1 = list(tp1)
list1.append('china')
print(list1)
tp1 = tuple(list1)
print(tp1)

4.3.4. 元组与列表的区别

        元组与列表都属于序列，都可以按照特定顺序存 储一组数据，类型不受限制

        列表类似使用铅笔在纸上书写的文字，可以擦 掉，元素类似钢笔写下的文字，不可擦除，只能 换一张纸重写

区别

        列表为可变序列，元素可以随时修改和删除， 元组为不可变序列，元素不可修改和删除，除 非整体替换

        元组不支持append() 、 extend() 、 insert() 等 方法进行添加删除操作

        元组和列表一样支持切片操作，但仅能通过切 片进行访问

        元组比列表结构简单，占用资源少，程序运行速度快

        元组比列表安全，若存储一组不可修改的数据则可以使用元组

4.4. 字典

        4.4.1. 概念：字典属于可变序列，使用 “键-值”（key-value）的方式配对存储数 据，类似于新华字典中的“拼音-汉字”的 关系。

        4.4.2. 格式：dictionary={key1： value1 ，key2：value2 ，……， keyn：valuen}

•  dictionar为字典名称
•  字典使用花括号{}作为标志
•  key1、key2、……、keyn为元素的键，必须唯 一，且不可变，可以是字符串、数字、元组
•  value1、value2、……、valuen：为元素的值，可为任意数据、不需要唯一

4.4.3. 字典创建示例：

dict1 = {'andy': 1001,'fox': 1002,'alice': 1003}
dict2 = {} # 创建空字典
dict3 = dict() # 使用dict()方法创建空字典
name = ["春香","秋兰","夏凝","翠花"]
sign = ["天平座","射手座","金牛座","双鱼座"]
dict4 = dict(zip(name, sign)) #使用
zip()函数将列表或元组对应的元素组合为字典
dict5 = dict(a=98.5, b=44.6, c=55.9,
d=88.7)
print(dict1,'\n', dict2,'\n',dict3,'\n', dict4,'\n', dict5)
# 键值赋值方法创建,使用key=value时，key不能为常量，必须为标识符

4.4.4. 增加字典元素

格式： dictname[ 键 ]= 值

例：

dict1 = {'西瓜': 5,'香蕉': 8,'荔枝':10}
dict1['橘子'] = 6
dict1['荔枝'] = 12
print(dict1)

4.4.5. 删除字典

• del 字典名[键]：删除特定元素
• dictionary.clear() :清空字典全部元素
• del 字典名 ： 删除字典

dict1 = {'西瓜': 5,'香蕉': 8,'荔枝':10}
del dict1['西瓜']
print(dict1)
dict1.clear()
print(dict1)
del dict1

4.4.6. 访问字典：dictionary[键]

dict = {'Name': 'Zara','Age': 7,'Class': 'First'}
print("dict['Name']: ", dict['Name'])
print("dict['Age']: ", dict['Age'])

4.4.7. 字典的复制

• 作用：为了保护原先字典的内容
• 格式：new_dictname = dictname.copy()

dict1 = {'西瓜': 5,'香蕉': 8,'荔枝':10}
dict2 = dict1.copy()
print(dict1)
print(dict2)
print(id(dict1), id(dict2)) # 深拷贝，新字典地址独立

4.4.8. 使用get()方法获取指定的键值

• 格式：dictionary.get(key , default )
• key：指定键
• default：可选，用于指定键不存在时，返回的默认值，若省略则返回None

dict1 = {'Name': 'Zara','Age': 7,'Class': 'First'}
print(dict1.get('Age'))
print(dict1.get('score','无此选项'))
# 访问的键若不存在，则执行default

4.4.9. 字典的遍历

• 格式1:遍历值，items()方法

         for i in dictionary.items(): 处理i

• 格式2：键：值方法，items（）

        for key , value in dictionary.items():

                处理key 与 value

name = ["春香","秋兰","夏凝","翠花"]
sign = ["天平座","射手座","金牛座","双鱼座"]
dict1 = dict(zip(name, sign))
for i in dict1.items():
print(i)
for i, j in dict1.items():
print(i,"的星座是:", j)

• 格式3：遍历字典的键，keys( )方法

        for key dictname.keys( ):

                处理

players = {'张三': 77.5,'李四': 55.9,'王五': 89.2}
for name in players.keys():
print('姓名:', name)

注意1:不允许同一个键出现两次。创建时如果同 一个键被赋值两次，后一个值会被记住

dict1 = {"num": 1001,"score": 98.5,"num": 1002}
print(dict1) # 结果：{'num': 1002,'score': 98.5}

注意2：键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

dict1 = {["num"]: 1001,"score": 98.5}
print(dict1) #报错

4.4.10. 常见方法：get、items、keys和 values是核心

4.4.11. 字典内含列表元素

列表存储在字典中时此列表为该字典某键的值， 需要使用嵌套循环完成遍历，外层循环取得字典 的键，内层循环将含列表的值拆解

sports = {'andy': ['篮球', '足球', '橄榄球'], 'jenny': ['体操', '游泳'], 'fox': ['羽毛球', '乒乓球', '棒球', '骑行']}
for name, na_sport in sports.items():  # 键：值复制给name, na_sport
    print('%s喜欢的运动是：' % name, end=' ')
for sp in na_sport:  # 单独处理列表
    print(' ', sp, end=' ')
print()

4.4.12. 字典内含字典

字典允许将字典存储在字典内，此时字典将是该 字典某个键的值

wechat = {'001': {'last_name': '张三', 'first_name': '张三丰', 'city': '西安'},
          '002': {'last_name': '李四', 'first_name': '李时珍', 'city': '咸阳'}}
for num, name in wechat.items():
    print('账号:', num, end=' ')
print('姓名:', name['first_name'], end=' ')
print('住址:', name['city'])

4.4.13. 字典的fromkeys()方法

• 作用：建立字典的一种方法
• 格式：dictname=dict.fromkeys(seq , value)
• seq:建立字典的列表，默认为键
• value：字典的值，若省略则为None

sq = ['name','city']
dict1 = dict.fromkeys(sq)
print(dict1)

4.5. 集合

4.5.1. 概念：集合是一个无序不重复元素 的集

4.5.2. 功能：关系测试和消除重复元素

4.5.3. 集合使用大括号({})框定元素，并 以逗号进行分隔。

4.5.4. 格式1：setname={value1， value2，……，valuen}

set1 = {1, 2, 3, 4, 5}
set2 = {"name","num","age","score"}
# 集合本质为无序可变集合，输出时顺序可能不同
set3 = set("命运给予我们的不是失望之酒，而是机会之杯") # 使用set（）函数创建
set4 = set([1.2, 3.4, 5.6, 7.8]) # 使用set（）函数创建
set5 = set() # 为set()，不能为{}
set6 = set(("apple",)) #必须增加逗号
print(set1,'\n',set2,'\n',set3,'\n',set4,'\n',set5,'\n',set6)

4.5.5. 集合应用的核心：去重

• 大数据中海量数据去重时只需要使用python的集合功能即可

list1 = [1, 1, 2, 3, 4, 3, 2, 2, 1, 2,3, 3, 3, 2, 2, 3, 2, 2, 5, 6, 4, 7, 5,6, 4, 7, 9, 8,7, 8, 9]
x = set(list1)
list1 = list(x)
print(list1)

4.5.6. 集合的添加和删除

• 添加元素：setname.add(element)

set1 = set(["java","C","c#","android"])
set1.add("python")
print(set1)
set1.add("C") # 添加重复值无用
print(set1)

删除元素

set1 = set(["java","C","c#","android","python"])
print(set1)
set1.remove("java") # 删除指定元素
print(set1)
set1.pop() # 随机删除一个元素
print(set1)
set1.clear() # 清空
print(set1)

4.5.7. 集合的交集、并集、差集运算

交集： &

 并集：|

 差集：-

对称差集： ^ ， 获得 A 与 B 两个集合，同事排除共同

 例1：
 

set1 = set("abcdefg")
set2 = set("efghijk")
print(set1 & set2)
print(set1 | set2)
print(set1 - set2)
print(set1 ^ set2)

4.5.8. 集合判断是否相等

• 符号：== 和 ！=
• 返回值：True 和 False

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}
C = {1, 2, 3, 4}
print(A == B, A == C)

4.5.9. 其它操作：in not in add() copy() remove() pop() clear() max() min() sum() len()sorted()与

4.5.10. 特殊操作

• isdisjoint():两个集合没有共同元素则返回True

A = {1, 2, 3, 4}
B = {5, 6, 7, 8}
print(A.isdisjoint(B))

• issubset():测试是否为子集

A = {1, 2, 3, 4}
B = {1, 2, 3, 4, 5, 6, 7, 8}
print(A.issubset(B))

• issuperset():测试是否为父集

A = {1, 2, 3, 4, 5, 6, 7, 8}
B = {1, 2, 3, 4}
print(A.issuperset(B))

• update（）：将一个集合加到另一个集合内容

A = {1, 2, 3, 4}
B = {5, 6, 7, 8}
A.update(B)
print(A)

• difference_update():删除集合内与另一个集合重复的元素

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}
A.difference_update(B)
print(A)

4.5.11. 冻结集合（frozenset）

        概念：set 是可变集合， frozenset 是不可变集合 也称为冻结集合，定义好之后内容不可更改，操 作参照元组

x = frozenset([1, 3, 5])
y = frozenset([5, 7, 9])
print(x, y)
print(x & y, x | y, )

4.5.12. 查看集合的操作方法：dir(set)

print(dir(set))

print(dir(list))

4.6. 列表、元组、字典、集合区别

数据结构	是否可变	是否重复	是否有序	定义符号
列表（list）	可变	可重复	有序	[]
元组（tuple）	不可变	可重复	有序	（）
字典（dict）	可变	可重复	无序	{key：vlaue}
集合（set）	可变	不可变	无序	{ }

4.7.字符串

4.8.1概念：字符串是由''或'' ''包裹起来的任意不可变文本序列,双引号'

print('吉多，范罗苏姆外号"龟叔"')



str1='china'  #字符串    不可变
print(str1[0])
str1[1]='H'

str2=['china','hello','nihao']  #字符串列表
str2[0]='CHINA'

4.8.2.拼接字符：+

str1 = '我今晚跑步'
num = 3200
print(str1 + str(num))
#注意：字符串的拼接对象只能是字符串

4.8.3多行字符串

字符串长度多于一行时，可以使用三引引号将字符串夹

str1 ='''china china china
china china 
china china china'''
print(str1)

4.8.4.字符串的切片

原则：字符串属于不可变序列，可以通过切片实现字符截取

格式：strname[start,end,step]

start:从0索引开始

end：最后一个字符串的索引（不包含）

step：切片长度，默认为1

str1='2022,加油，中国'
print(str1) 
print(str1[0])
print(str1[0:])
print(str1[5:])
print(str1[0:3])
print(str1[2:6])
print(str1[1:10:2])
print(str1[-1:-3:-1])

例1：输入员工身份证号，输出出生日期

id=(input("请输入身份证号："))
#str1='412702199505053678'
print(id[6:10])
print('你的身份证号是：',id)
if int(id[16])%2==1:
    print('性别：男')
else:
    print('性别：女')
print('输出日期：'+id[6:10]+'年'+id[10:12]+'月'+id[12:14]+'日')

4.8.5.分割合并字符串

分割：将字符串分割为列表

格式:strname.split(sep,maxsplit)

        sep:指定分割符，可以包含多种符号（空格，\n,\t 等），默认为None

maxsplit：指定分割次数

str1='python 软件官网 >>> https://www.python.org/'
print('原串：',str1)
list1=str1.split()
list2=str1.split('>>>')
list3=str1.split('.')
list4=str1.split(" ",3)
print(list1,list2,list3,list4,sep='\n')




原串： python 软件官网 >>> https://www.python.org/
['python', '软件官网', '>>>', 'https://www.python.org/']
['python 软件官网 ', ' https://www.python.org/']
['python 软件官网 >>> https://www', 'python', 'org/']
['python', '软件官网', '>>>', 'https://www.python.org/']

• 合并字符串：将多个字符串采用固定的分割符进行连接
• 格式：strnew=string.join(iterable)
• strnew:新串名称
• string：合并时的分隔符
• iterable：可迭代对象，即被合并的字符串

4.8.6字符串查找

count（）方法

作用：检索字符串在另一串中出现的次数，若不存在返回0

格式：strname.count(substring) substring 为要检索的字符串

str1='***ABC***def***'
cn1=str1.count('*')
cn2=str1.count('?')
print('次数:',cn1,cn2)

str1='aaaaaaaaaa'
cn1=str1.count('aa')
print('次数:',cn1,)

find（）方法

作用：检索是否包含指定字符串，若不存在则返回-1，否则返回首次出现的索引值

格式：strname.find(sub)

str1=input('输入主串：')
str2=input('输入子串：')
num=str1.find(str2)
if num > -1:
    print('存在，第一次出现的索引：' ,num)
else:
    print('不存在')

注意：find（）一般用于在主串中查找子串是否存在，还可以使用in实现

str1=input('输入主串：')
str2=input('输入子串：')
print(str2 in str1)

• startswitch（）方法：检索字符串是否可以指定字符串开头
• endswitch（）方法：检索字符串是否可以指定字符串结尾

4.8.7.字母大小写转换

• 大写>小写：strname.lower()
• 小写>大写：strname.upper()
• 大小写互换函数：strname.swapcase()

str1=input()
print(str1.upper())

4.8.8.判断是否为字母

格式;strname.isalpha()

成立返回True，否则返回False

例：判断字符串中字母出现的次数

str1=input('请输入字符串：')
cnt={}   #定义空字典
for i in  str1:
    if  i.isalpha()==True:
        #get（i，0）计算i对应的值
        cnt[i]=cnt.get(i,0)+1
print(cnt)



请输入字符串：12asdcasda
{'a': 3, 's': 2, 'd': 2, 'c': 1}

4.8.9.字符串删除

• strname.strip(char):删除字符串左右指定字符
• strname.lstrip(char):删除字符串左则指定字符
• strname.srtrip(char):删除字符串右则指定字符
• 默认删除所有空白字符（\n  \t  \r   空格）

例1:统计字符串中单词个数

str1 = input('请输入字符串：')
str1 = str1.strip()  # 删除左右两侧的空格
cnt = 1
i = 0
while i < len(str1) - 1:
    if str1[i] != ' ' and str1[i + 1] == ' ':
        cnt += 1
    i += 1
if str1 == '':
    cnt = 0
print('单词个数：', cnt)

• strname.replace('需替换字符串'，‘替换结果’)

str1='***ABC***123***'
print(str1.replace('*','?'))



???ABC???123???

4.8.10.字符串文本对齐

方法：

        center：居中

        ljust：左对齐

        rjust：右对齐

4.8.11.程序案例

例1编写程序,检测输入的字符串密码是否是一个合法的密码。规则如下：

密码必须至少8个字符

密码只能包含英文和数字

密码至少包含2个数字

str1=input('请输入密码：')
t=0
for i in str1:
    if  i.isdigit():  #判断字符串是否是数字
        t+=1
if len(str1)>=8:
    if str1.isalnum():  #判断字符串是否包含字母和数字
        if t>2:
            print('密码正确')
        else:
            print('密码包含的数字至少于2个')
    else:
        print('密码只能包含字母和数字')        
else:
    print('密码至少要有8个字符')

例2:编写程序：实现输入二进制数转为十进制

如：1001十进制为9，即执行1*2

str1=input('请输入二进制:')
d1=0 #接收转换结果
t=0  #权值
f=1
if str1.isnumeric():   #判断字符串至少有一个字符且所有字符均
    str2=str1[::-1]   #str2存储逆序
    for i in str2:
        if i=='1' or i=='0':
            d1=d1+int(i)*2*t
        else:
            print('无效数字')
            f=0
            break
        t+=1  #权值加1
    if  f:
        print(str1,'转为十进制整数：',d1)

例 3 ：国际标准书号包含 10 个数： d1d2d3d4d5d6d7d8d9d10, 最后一个 d10 位校验位，计算公式：

根据规范，若 d10 计算结果为 10 ，则使用 X 表 示，编写程序，输入前 9 个内容的字符串，输 出标准书号

str1=input('请输入国际标准书号前9位：')
check=0
t=1
for i in str1:
    check=check +int(i)+t
    t+=1
check%=11
if check ==10
    check='x':
print(str1+str(check))

例 4 ：统计字符串中字母个数存储到列表 b[26] 中， a 个数存储到 b[0],b 个数存储到 b[1],z 个数存储到 b[25]

str1=input('请输入英文字符串')
b=[0]*26  #b列表全部清零
str1=str1.lower()  #大转小写字母
for i in str1:
    if i.isalpha():  #判断是否是字母
        b[ord(i)-97]+=1  #当前字母ascii值减去首字母ascii值序号
print(b)

方法二

str1=input('请输入英文字符串')
b=[0]*26  #b列表全部清零
str1=str1.lower()  #大转小写字母
for i in  range(26):
    b.append(str1.count(chr(97+i)))
print(b)

例;将字符串中大小写字母改写为下一个字母，Z字母改为A

str1 = input('请输入英文字符串')
for i in str1:
    if i >= 'A' and i <= 'Y':
        i = chr(ord(i) + 1)
    else:
        if i == 'Z':
            i = 'A'
    print(i, end='')

上例改为：将大写字母改为上一个，A改为Z

例6：将2个串逆置后交叉合并到新串中，如：str1：abcdef  str2：12345678.  str3：

str1 = input('请输入英文字符串')
str2 = input('请输入英文字符串')
print(str1)
print(str2)
str1 = str1[::-1]
str3 = ''
i = 0
j = 0
while i < len(str1) or j < len(str2):
    if i < len(str1):
        str3 += str1[i]  # 拼接
    if j < len(str2):
        str3 += str2[i]
    j += 1
    j += 1
print(str3)

例7：字符串排序，python中字符串类不允许直接修改元素，需要将其转为列表在后进行排序，排完后转回字符串

str1='987654321'
list1=list(str1)
list1.sort()
str1=''.join(list1)
print(str1)
print(type(str1))

例8：排除字符串首尾2个元素，剩余内容排序

str1=input('请输入一个字符串')
str2=str1[1:len(str1)-1]
list1=list(str2)
list1.sort()
str2=''.join(list1)
print(str1[0]+str2+str1[len(str1)-1])

4.8.12.格式化字符串

概念：格式化字符串是指定一个模板，该模板流出空位，在根据需要填上相应的内容

通过操做%实现：''%[-][+][0][m][.n]'%格式化字符exp

参数说明：

[]:表示内容可选

-：右对齐

+：右对齐

0：右对齐，用0填充空白，一般配合参数m使用

m:宽度

n：小数保留位数

%格式化字符如下表：

格式化	作用	格式化字符	作用
%s	字符串	%r	字符串
%c	单个字符	%o	八进制
%d   %i	十进制	%e	指数
%x	十六进制	%E	指数
%f %F	浮点数	%%	字符

str1 = '编号：%05d\t公司名称：%s官网：https://www.%s.com'
str2 = (1, '百度', 'baidu')
str3 = (2, '腾讯', 'qq')
str4 = (3, '字节跳动', 'bytedance')
print(str1 % str2)
print(str1 % str3)
print(str1 % str4)

4.8.13通过format（）方法实现

• Python2.6版本以后推荐使用format（）方法格式化字符串
• 格式：str.format(args)
• 参数分析
  • str：字符串显示的样式即模板
  • args：需要转换的对象，若有多项可以使用逗号分隔
• 占位符：{}和：
• 模板格式：{index：fill  aglin  sign   #   width.percision  type}
  • index:索引位置，从0开始，若省略则自动分配
  • fill：空白填充的字符
  • aglin：对齐方式，一般与width匹配使用
  • <:左对齐
  • >:右对齐
  • =：内容右对齐，只有数字类型有效，即将数字放在填充字符的最右则
  • ^:内容居中
  • sign：指定有无符号：
  • +：正数
  • 负数
  • 空格：正数加正号，负号加符号

        #:值为二，八，十六进制时，数字显示0b，0o，0x的前缀

        wifth：宽度

        .percision:保留的小数位数

        type：类型

str1 = '编号：{:0>5s}\t公司名称：{:s}官网：https://www.{:5}.com'
str2 = str1.format('1', '百度', 'baidu')
str3 = str1.format('2', '腾讯', 'qq')
str4 = str1.format('3', '字节跳动', 'bytedance')
print(str2)
print(str3)
print(str4)

import  math
print('￥{:,.2f}元'.format(2596+3874) )
print('{0:E}'.format(53000000.2))
print('{:.7f}'.format(math.pi))
print('二进制：{:#b}'.format(1001))
print('八进制：{:#o}'.format(1001))
print('十六进制：{:#x}'.format(1001))
print('天才是由{:.0%}的灵感，加上{:.0%}的汗水！'.format(0.01,0.99))

4.8.14.Python常见的字符串编码

• ASCII码：对10个数字，256英文大小写字母，其他字符进行编码，最多表示256个字符，每个字符占1b
• GBK\GBK2312:中文汉字编码，1b表示英文子母，2B表示汉字
• Unicode和utf-8的关系
  • Unicode：称为万国码，统一码，用于满足跨语言，跨平台的文件转换处理要求
  • unicode：包含全球所有国家的字符编码的映射关系，已达到编码的统一使用
  • unicode表示字符太浪费空间，为了解决字符的存储和传输问题而产生了UTF-8编码
• UTF:(unicode   transformation   format)：对unicode进行转换，以便于在存储和传输时节省空间和时间
  • UTF-8:使用1，2，3，4个字节表示字符，有先使用1B表示字符，无法满足时增加1B,,最多4B，英文占1B，欧洲语系占，2B，东亚语系占3B，其他的特殊字符占4B
  • UTF-16:使用2，4字节表示字符
  • UTF-32:使用4B表示字符
  • 总结：UTF 编码时为UNICODE编码设计的一种在存储和传输时节省空间的编码方案
• python的2种字符串类型
  • str：在内存中使用unciode表示字符串
  • bytes：字节类型，网络传输或存储时磁盘使用二进制数据表示，以b开头如”

                b'\xs2\xb0'

• 使用encode（）方法编码        
  • 作用：将字符串转为二进制（bytes）数据
  • 格式：strname。encode（encoding=）

str1='书山有路勤为径'
by1=str1.encode('GBK')
by2=str1.encode()
print('原串：',str1)
print('转为GBK：',by1)
print('转为UTF-8:',by2)

• 使用decode（）解码        
  • 解码：将bytes类型二进制数据转换为字符串
  • 格式：bytes.decode(endcoding='UTF-8')

str1='学海无涯苦作舟'
by1=str1.encode('GBK')

print('解码后：',by1.decode('GBK'))

4.9.正则表达式

4.9.1.正则表达式用于描述字符串的复杂文本规则的代码，一般用于查询匹配

4.9.2常见元字符

作用表示特殊含义,一般为范围性，不好确切描述的字符串

单个字符匹配的元字符

字符	功能
.	匹配任意1个字符
[]
\d	匹配0-9数字
\D	匹配非数字
\s	匹配空白（空格，tab）
\S	匹配非空白
\w
\W	匹配非\W的字符

 数量元字符

 

字符	功能
*
?
+
{m}
{m,}
{m,n}
I

边界字符 

字符	功能
^	行首
$	行尾
\b	匹配单词的开始或结束，分解符为空格
\B	匹配非单词边界

分组元字符

字符	功能
I	匹配左右两边任意一个表达式
(ab)	将括号中的字符作为一个分组

4.9.3.实例

• 匹配8位qq号

^\b{8}$

• 匹配任意元音字母

[aeiou]

• 匹配身份证号：18位，前17位为数字，最后一位为x或X进行校验

（^\d{17}）(\d|X|x)$

• 匹配输入的163，126，qq，邮箱，前面至少5位最多11位

\w{5,11}@(163|126|qq.com)\.(com|cn)

r'\w{5,11}@(163|126|qq.com).(com|cn)'

• 检索python文件名位：xxxx.py

r'\w+\.py\b'

 4.9.4.re模块

需要加载：import    re

math（） 方法

        格式：re.math(pattern,string,[flags])

        作用：从字符串起始位置起开始查找匹配，成功返回math对象，否则返回None。只能匹配一个

        pattern：使用正则表达式表示的模式字符串

        string：要匹配的字符串

        flags：可省略，表示标准位，控制匹配方法，如：是否区分大小写子母等

标准	作用
A	ASCII码匹配
I	不区分大小写字母
M	将^和$应用于一行
S	使用（.）匹配所有字符
X	忽略空格，注释等

例：匹配字符串是否以mr——开头，不区分大小写

import  re
p=r'mr_\w+'  #模式字符串
str1='MR_SHOP mr_shop'
str2='MR_SHOP mr_shop'
m=re.match(p,str1,re.I)
print(m)

#返回的对象多功能方法
print('匹配值的起始位置：' ,m.start())
print('匹配值的结束位置：' ,m.end())
print('匹配值的元组：' ,m.span())
print('匹配值的数据：' ,m.group())

#只能在起始位置匹配
str1='123MR_SHOP mr_shop'
n=re.match(p,str2,re.I)
print(n)  #None

import  re
m=input('请输入手机号：')
p=fr'(13[4-9]\d{8})$|(15[01289]\d{8})$'
mt=re.match(p,m)
if  mt==None:
    print('不是移动号段')
else:
    print('是有效的中国移动手机号')

search（）方法匹配

import re

p = r'mr_\w+'  # 模式字符串
str1 = '123MR_SHOP mr_shop'
m = re.search(p, str1, re.I)
print(m)

findall（）方法

        作用：在字符串中检索所有符合正则表达式规则的字符串，并

  格式：re.math(pattern,string,[flags])