6.容器类型相关操作与函数

目录

• 一.字符串相关操作与函数
  • 1.字符串相关操作:拼接+, 重复 *,跨行拼接,索引,切片
  • 2.字符串的格式化:format
    • 多个格式化
    • 2.1顺序传参:{}是占位符
    • 2.2索引传参
    • 2.3关键字传参
    • 2.4容器类型数据(list tuple dict)传参
    • 2.5format填充符号的使用(^,<,>)
    • 2.6进制转换特殊符号的使用
  • 3.字符串的相关函数
    • 3.1capitalize字符串首字母大写
    • 3.2title 每个单词的首字母都大写
    • 3.3upper 将所有的字母变成大写
    • 3.4lower 将所有字母变小写
    • 3.5swapcase 大小写互换
    • 3.6len 计算字符串的长度
    • 3.7count 统计字符串中某个元素的数量
    • 3.8find 查找某个字符串第一次出现的索引位置
    • 3.9index(索引)与find功能一样,但是找不到结果自己报错
    • 3.10startswith 判断是否以某个字符串为开头 成立返回True,否则False
    • 3.11endswith 判断是否以某个字符串为结尾(和startswith一样)
    • 3.12isupper 判断字符串是否都是大写(是True,否False)
    • 3.13islower 判断字符串是否都是小写
    • 3.14isdecimal 检查字符串是否以纯数字组成
    • 3.15split 按某字符将字符串切割成列表(默认字符是空格)
    • 3.16join 按某个字符将列表拼接成字符串(容器类型都可以)
    • 3.17center 填充字符串,原字符串居中(默认填充空格)
    • 3.18strip 默认去掉首尾两边的空白符(空格, 我们看不到的字符)
    • 3.19replace()替换:把字符串中的旧字符换成新字符
    • 3.20 swapcase() 大小写翻转
    • 3.21 isdigit() 判断字符串是否只由数字组成
    • 3.22 isalpha() 判断字符串是否只由字母组成
    • 3.23 isalnum() 判断字符串是否由字符或数字组成
    • 3.24 字符串替换
• 二.列表相关操作与函数
  • 1.列表的相关操作
    • 1.1拼接:+(元组一样)
    • 1.2列表 的重复*(同元组)
    • 1.3列表的切片(同元组) :留头舍尾
    • 1.4列表的获取
    • 1.5列表的修改
    • 1.6列表的删除(可切片截取删除)
  • 2.列表的相关函数
    • 2.1增
    • 2.2删
    • 2.3index 获取某个值在列表中的索引 如果多个相同的值,只找第一个值的索引
    • 2.4count 计算某个元素出现的次数
    • 2.5sort 列表排序 (基于原有列表进行排序) 默认从小到大
    • 2.6reverse 列表的反转操作
• 三.字典相关操作与函数
  • 1.增
  • 2.删
  • 3.改
  • 4.查
  • 5.组成新的可迭代性对象
• 四.集合的相关操作与函数
  • 1.交差并补
  • 2.判断
  • 3.集合的增
  • 4.集合的删
  • 5.冰冻集合

一.字符串相关操作与函数

1.字符串相关操作:拼接+, 重复 *,跨行拼接,索引,切片

str1="jkj--"
str2="djk-"
print(str1+str2)    #拼接
print(str2*5)       #重复
print(str2[2])      #k 索引
strvar="fdsl"
"fdsffdsf"          #跨行拼接

# 切片[ : : ] =>[开始索引: 结束索引: 间隔值]    特点:留头舍尾 截取的方向要一致
strvar="空山新雨后,天气晚来秋"
# 1.[开始索引:] 从开始索引的位置到字符串最后
print(strvar[6:])
# 2.[:结束索引]    从开头到结束索引 的前一个字符
print(strvar[:5]) 
# 3.[开始索引:结束索引]    从开始索引的位置到结束索引的抢一个字符
print(strvar[2:5])
# 4.[::间隔值]     从头到尾取间隔值
print(strvar[::2])   
# 5.[开始索引:结束索引:间隔值]   从开始索引的位置到结束索引的前一个字符取间隔值
print(strvar[2:-2:3])

# 6.[::-1]  反向输出,注意截取方向要一致
print(strvar[::-1])
# 7.[:]或[::]    截取所有字符串

2.字符串的格式化:format

多个格式化

'b' - 二进制。将数字以2为基数进行输出。
'c' - 字符。在打印之前将整数转换成对应的Unicode字符串。
'd' - 十进制整数。将数字以10为基数进行输出。
'o' - 八进制。将数字以8为基数进行输出。
'x' - 十六进制。将数字以16为基数进行输出，9以上的位数用小写字母。
'e' - 幂符号。用科学计数法打印数字。用'e'表示幂。
'g' - 一般格式。将数值以fixed-point格式输出。当数值特别大的时候，用幂形式打印。
'n' - 数字。当值为整数时和'd'相同，值为浮点数时和'g'相同。不同的是它会根据区域设置插入数字分隔符。
'%' - 百分数。将数值乘以100然后以fixed-point('f')格式打印，值后面会有一个百分号。

2.1顺序传参:{}是占位符

strvar="{}喜欢{},呵呵".format("11","熊大")
print(strvar)

2.2索引传参

strvar="{1}和{0}是好朋友".format("熊二","熊大")
print(strvar)

2.3关键字传参

strvar="{who}居住在{where}".format(who="熊大",where="山沟里")
print(strvar)

2.4容器类型数据(list tuple dict)传参

strvar="{1[0]}和{0[1]}是朋友".format(["熊大","熊二"],("吉吉国王","光头强"))
print(strvar)
# 字典在format格式化使用中,键不能再加引号了
strvar="{0[xd]}和{0[xe]}是好人".format({"xd":"熊大","xe":"熊二"})
print(strvar)

2.5format填充符号的使用(^,<,>)

"""
^:传入的参数居中
<:传入的参数居左
>:传入的参数居右

格式:{who:*^10}
who:关键字传参
*     :要填充的符号
^     :原字符串居中
10    :填充符号与传入的参数的总个数
如果不写填充符号,默认填充空格
"""
strvar="{:^10}和{:*^10}在一起{:!<7}".format("关头强","熊大","玩")
print(strvar)

2.6进制转换特殊符号的使用

 # :d 整型占位符(传入的参数必须是整数)
strvar="今天吃了{:d}顿饭".format(66)
strvar="今天吃了{:*^5d}顿饭".format(66)
print(strvar)

# :f 浮点型占位符(传入的参数必须是浮点型)默认保留6为小数
strvar="苹果{:.2f}元一斤".format(22.2254)#:.2f 保留2位小数,四舍五入
print(strvar)

# :s 字符串占位符(传入的参数必须是字符串)
strvar="{:^7s}真好看".format("小龙女")
print(strvar)

# :,金钱站位符(三位,三位)
strvar="{:,}".format(32454653)
print(strvar)

strvar="{:s}今天吃了{:^2d}花了{:^12.2f}".format("光头强",4,32.34344)
print(strvar)

3.字符串的相关函数

3.1capitalize字符串首字母大写

strvar="hello world"
res=strvar.capitalize()
print(res )

3.2title 每个单词的首字母都大写

res=strvar.title()
print(res)

3.3upper 将所有的字母变成大写

res=strvar.upper()
print(res)

3.4lower 将所有字母变小写

strvar="LKKLHLLKLJHKL".lower()
print(strvar)

3.5swapcase 大小写互换

3.6len 计算字符串的长度

strvar="haohaohao"
print(len(strvar))

3.7count 统计字符串中某个元素的数量

#格式:count(字符,[开始索引,结束索引])
strvar="you can you up ,no can no bb"
res=strvar.count("you")
res=strvar.count("o")
res=strvar.count("o",5)
res=strvar.count("o",5,10)
print(res)

3.8find 查找某个字符串第一次出现的索引位置

''' find(字符,[start,end])    如果找不到对应字符,返回-1'''
strvar="you can you up ,no can no bb"
res=strvar.find("can")
res=strvar.find("can",5)
res=strvar.find("can",5,6)
print(res)

3.9index(索引)与find功能一样,但是找不到结果自己报错

3.10startswith 判断是否以某个字符串为开头 成立返回True,否则False

"""startswith(字符,开始索引,结束索引)"""
strvar="how old are you"
res=strvar.startswith("how")
res=strvar.startswith("o",5)
print(res)

3.11endswith 判断是否以某个字符串为结尾(和startswith一样)

3.12isupper 判断字符串是否都是大写(是True,否False)

strvar="HLJ"
res=strvar.isupper()
print(res)

3.13islower 判断字符串是否都是小写

3.14isdecimal 检查字符串是否以纯数字组成

*isalpha 判断字符串是否由字母和文字组成 
*isdigit 检测字符串数是数字组成 接受二进制字节流 
*isdecimal 检测字符串是否以数字组成  必须是纯数字
#isnumeric 检测字符串是否以数字组成 接受中文"四"
#isspace   判断字符串是否由空白符组成

3.15split 按某字符将字符串切割成列表(默认字符是空格)

"""
split(字符,切割次数)从左到右
rsplit 从右到左
"""
strvar="1 2 3 4 5"
res=strvar.split()
res=strvar.split("k")
res=strvar.split("k",5)
res=strvar.rsplit(" ",3)
print(res)

3.16join 按某个字符将列表拼接成字符串(容器类型都可以)

#格式:字符.join(容器名)
var =["111","222","333"]
res='666'.join(var)
print(res)

3.17center 填充字符串,原字符串居中(默认填充空格)

"""
格式:center(填充字符数量,填充符号)
填充符号数量=原字符串字符数量+填充符号的数量
"""
strvar="*****"
res=strvar.center(10)
res=strvar.center(10,"@")
print(res)

3.18strip 默认去掉首尾两边的空白符(空格, 我们看不到的字符)

strvar="***好人****"
res=strvar.strip()
res=strvar.rstrip()#去掉右边空白字符
res=strvar.lstrip()#去掉左边空白符
res=strvar.strip("*")#去掉指定字符
print(res)

3.19replace()替换:把字符串中的旧字符换成新字符

#格式:字符串.replace("旧字符","新字符",替换次数)
strvar="你是好人,好人,好人"
res=strvar.replace("好人","坏人")
res=strvar.replace("好人","坏人",2)     
print(res)

3.20 swapcase() 大小写翻转

#格式:字符串.swapcase()
strvar="abcDEF"
print(strvar.swapcase()) # ABCdef

3.21 isdigit() 判断字符串是否只由数字组成

#格式:字符串.isdigit()
print('234'.isdigit()) # True
print('sf23%#'.isdigit()) # False

3.22 isalpha() 判断字符串是否只由字母组成

#格式:字符串.isalpha()
print('sfDD'.isalpha()) # True
print('sfd34'.isalpha()) # False

3.23 isalnum() 判断字符串是否由字符或数字组成

#格式:字符串.isalnum() 
print('234'.isalnum()) # True
print('sfadD'.isalnum()) # True
print('sdf34'.isalnum()) # True
print('sdf34#$'.isalnum()) # False

3.24 字符串替换

#maketrans translate 是一对
maketrans()
	功能:   制作用于字符串替换的映射表(一个字符对应一个字符)
	格式:   字符串.maketrans('查找字符','替换字符')两个字符必须长度相等
	返回值: 字典
translate()
	功能:   进行字符串替换操作
	格式:   字符串.translate(maketrans返回的字典)
	返回值: 替换之后的字符串
strvar="明月即使有，八九问侵吞天"
res=strvar.maketrans("即使侵吞","几时青天")
print(res,type(res))#{21363: 20960, 20351: 26102, 20405: 38738, 21534: 22825}
res=strvar.translate(res)
print(res)	#明月几时有，八九问青天天

二.列表相关操作与函数

1.列表的相关操作

1.1拼接:+(元组一样)

lst1=[111,222]
lst2=[333,444,[55,66]]
print(lst1+lst2)

1.2列表 的重复*(同元组)

print(lst1*3)

1.3列表的切片(同元组) :留头舍尾

#语法与字符串一样:=>列表[开始索引:结束索引:间隔值]
lst=[1,2,3,4,5,6,7,8,9,10]
print(lst[2:])
print(lst[:3])
print(lst[3:7])
print(lst[::-2])

1.4列表的获取

print(lst[3])

1.5列表的修改

# 一次修改一个
lst[1]="呵呵"
print(lst)
# 一次修改多个,等号右边必须是Iterable(容器类型,range对象,迭代器)
lst[1:2]="abcd"#左右数量可以不一致
lst[1:2]=range(100,110)
print(lst)
# 一次修改多个带步长的,截取几个数据,只能修改几个数据
lst=[1,2,3,4,5,6,7,8,9,10]
lst[::2]="abcde"
print(lst)

1.6列表的删除(可切片截取删除)

lst=[1,2,3,4,5,6,7,8,9,10]
del lst[0]
del lst[1:3]
del lst[::2]
print(lst)

2.列表的相关函数

2.1增

# append 向列表的末尾添加新的元素
lst=[11,22]
lst.append(33)
print(lst)
# insert 在指定索引之前插入元素
lst =[1,2,3,4,5]
lst.insert(2,666)
print(lst)
# extend 迭代追加所有元素(必须是可迭代性数据)
lst =[1,2,3,4,5]
var="ABCD"
lst.extend(var)
print(lst)

2.2删

# 1.pop通过指定索引删除元素,若没有索引,删除最后一个元素,返回被删除元素
lst =[1,2,3,4,5,6,7,8,9]
res=lst.pop()
res=lst.pop(2)
print(lst)
print(res)
# 2.remove 通过给予的值删除,如果多个相同元素,默认删除第一个
lst =[1,2,3,4,5,1,2,3,6,7,8,9]
lst.remove(2)
print(lst)
# 3.clear 清空列表
lst.clear()
print(lst)

2.3index 获取某个值在列表中的索引 如果多个相同的值,只找第一个值的索引

#如果找不到该数据,直接报错
lst =[1,2,3,4,5,1,2,3,6,7,8,9]
res =lst.index(6)
print(res)

2.4count 计算某个元素出现的次数

#无法像字符串中的count那样写开始和结束索引
res=lst.count(2)
print(res)

2.5sort 列表排序 (基于原有列表进行排序) 默认从小到大

lst =[1,2,3,4,5,1,2,3,6,7,8,9]
lst.sort()
print(lst)
"""从大到小"""
lst.sort(reverse=True)
print(lst)

2.6reverse 列表的反转操作

lst=[33,44,111,222,333,444,11,22]
lst.reverse()
print(lst)

三.字典相关操作与函数

1.增

#手动添加数据(推荐)
dic={}
dic["a"]=11
dic['b']=22
dic["c"]=33
print(dic)
"""
fromkeys() 使用一组键和默认的值创建字典(不推荐使用)
lst=["a","b","c"]
dic={}.fromkeys(lst,[] )
dic["a"].append(1)	想添加一个元素
print(dic)
输出结果:{'a': [1], 'b': [1], 'c': [1]}	所有元素都变了
键所指向值的地址是一个,不独立
"""

2.删

# 1.pop() 通过建删除键值对(若没有该键可设置默认值,防止报错)
dic={"a":11,"b":22,"c":33}
res=dic.pop("b")
res=dic.pop("bb","抱歉")# 若没有该键可设置默认值,防止报错
print(res)	#没有键,输出抱歉
print(dic)
# 2.popitem() 删除最后一个键值对
dic={"a":11,"b":22,"c":33}
dic.popitem()
print(dic)
# 3.clear() 清空字典
dic={"a":11,"b":22,"c":33}
dic.clear()
print(dic)

3.改

# update() 批量更新(有该键更新值,没该键就添加)
dic={"a":11,"b":22,"c":33}
dic1={"c":5,"d":6,"f":7}
dic.update(dic1)	#方法一
dic.update(aa=111,bb=222)#方法二
print(dic)

4.查

# get() 通过建获取值(若没有该键可设置默认值,防止报错)
dic={"a":11,"b":22,"c":33}
res=dic.get("a")
res=dic.get("sss","该键找不到")
print(res)

5.组成新的可迭代性对象

# keys() 将字典的键组成新的可迭代对象
dic={"a":11,"b":22,"c":33}
res=dic.keys()
print(res)

# values() 将字典中的值组成新的可迭代对象
dic={"a":11,"b":22,"c":33}
res=dic.values()
print(res)

# items() 将字典的键值对凑成一个个元组,组成新的可迭代性对象
dic={"a":11,"b":22,"c":33}
res=dic.items()
print(res)
for i,j in res:
    print(i,j)

四.集合的相关操作与函数

1.交差并补

set1={11,22,33,44,55}
set2={44,55,66,77,88}
# 1.交集:intersection 或 &
res=set1.intersection(set2)
res=set1 & set2
print(res)
# 2.差集:difference 或 -
res=set1.difference(set2)
res=set1-set2
print(res)
# 3.并集:union 或 |
res=set1.union(set2)
res=set1 | set2
print(res)
# 4.对称差集(扣掉交集部分,包含补集)symmetric_difference 或 ^
res = set1.symmetric_difference(set2)
res = set1 ^ set2
print(res)

2.判断

set1={1,2,3}
set2={1,2,3,4,5,}
# 1.isdisjoint() 检查两个集合是否不相交,不相交True 否则False
res=set1.isdisjoint(set2)
print(res)
# 2.issubset() 判断是否是子集
res=set1.issubset(set2)
print(res)
# 3.issuperset() 判断是否是父集
res = set1.issuperset(set2)
print(res)

3.集合的增

# 1.add() 向集合中添加数据(一次加一个)
setvar={11}
setvar.add(22)
print(setvar)
# 2.update() 迭代增加(可迭代性数据)
setvar={1,2,3,4}
lst=range(2,10)
setvar.update(lst)
print(setvar)	#集合自动去重

4.集合的删

# 1.pop() 随机删除集合中的一个数据
setvar={1,2,3,4}
setvar.pop()
print(setvar)
# 2.remove 删除集合中指定的值(不存在报错)不推荐使用
setvar={1,2,3,4,5}
setvar.remove(4)
# setvar.remove(6)	报错
print(setvar)
# 3.discard() 删除集合中指定的值(不存在不报错,推荐使用)
setvar={11,22,33,44,55,66}
setvar.discard(33)
setvar.discard(222)	#不报错,程序还能执行
print(setvar)
# 4.clear() 清空集合
setvar={2,33,4,5}
setvar.clear()
print(setvar)

5.冰冻集合

'''冰冻集合一旦创建,不能再进行任何修改,只能做交差并补操作'''
# frozenset :可强转容器类型数据变为冰冻集合
lst=[1,2,3,4,5]
fz=frozenset(lst)
print(fz,type(fz))