Python全栈之字符串和列表相关操作

目录

• 1. format格式化_填充符号使用
• 1.1 format格式化
• 1.2 format的填充符号的使用
• 2. 字符串相关的方法
• 3. 列表的相关操作
• 4. 列表的相关函数
• 5. 深浅拷贝
• 小提示：
• 6. 小练习
• （1）字符串相关练习问题：
• （2）列表相关练习问题：
• 总结

1. format格式化_填充符号使用

1.1 format格式化

字符串的格式化format

# (1)顺序传参
"""{}是format中的占位符"""
strvar = "{}向{}开了一枪,饮蛋而亡".format("赵沈阳","需保障")
print(strvar)
# (2)索引传参
strvar = "{1}向{0}开了一枪,饮蛋而亡".format("赵沈阳","需保障")
print(strvar)
# (3)关键字传参
strvar = "{who1}摸了{who2}一下,回头一巴掌".format(who1="王伟",who2="马春妮")
strvar = "{who1}摸了{who2}一下,回头一巴掌".format(who1="马春妮"编程客栈,who2="王伟")
print(strvar)
# (4)容器类型数据(列表或元祖)传参
# 方法一
strvar = "{0[0]}摸了{1[1]}一下,嘿嘿一笑,有戏".format(["赵蜂拥","赵世超","杨元涛"] , ("王雨涵","王同培"))
print(strvar)
# 方法二(推荐)
strvar = "{group1[0]}摸了{group2[1]}一下,嘿嘿一笑,有戏".format(group1=["赵蜂拥","赵世超","杨元涛"] , group2 = ("王雨涵","王同培"))
print(strvar)
# 方法三(推荐) 注意一.如果该容器是字典,通过键取值时,不需要加引号  注意二.通过下标取值时,不能使用负号(逆向索引)
strvar = "{group1[zfy]}摸了{group2[-1]}一下,嘿嘿一笑,有戏".format(group1={"zfy":"赵蜂拥","zsc":"赵世超"} , group2 = ("王雨涵","王同培"))
print(strvar)

1.2 format的填充符号的使用

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

"""
^ 原字符串居中显示
> 原字符串居右显示
< 原字符串居左显示
{who:*^10}
* : 填充的符号
^ : 原字符串居中显示
10: 原字符串长度 + 填充符号的长度 = 10
"""
strvar = "{who:*^10}去长春长生医药公司,{do:>>10},感觉{feel:!<10}".format(who="李亚峰",do="扎疫苗",feel="血槽被掏空")
print(strvar)

# (6)进制转换等特殊符号的使用( :d :f :s :, )
# :d 整型占位符 (强制要求类型是整型)
strvar = "刘一峰昨天晚上买了{:d}个花露水泡脚".format(9)
print(strvar)
# :3d 占3位,不够三位拿空格来补位(原字符串居右)
strvar = "刘一峰昨天晚上买了{:3d}个花露水泡脚".format(9)
print(strvar)
strvar = "刘一峰昨天晚上买了{:<3d}个花露水泡脚".format(9)
print(strvar)
strvar = "刘一峰昨天晚上买了{:^3d}个花露水泡脚".format(9)
print(strvar)
# :f 浮点型占位符 (强制要求类型是浮点型) 默认保留小数6位
strvar = "王雨涵毕业之后的薪资是{:f}".format(9.9)
print(strvar)
# :.2f 小数点后保留2位,存在四舍五入
strvar = "王雨涵毕业之后的薪资是{:.2f}".format(9.188888)
print(strvar)
# :s 字符串占位符
strvar = "{:s}".format("杨元涛真帅")
print(strvar)
# :, 金钱占位符
strvar = "{:,}".format(12345678)
print(strvar)
# 综合案例
strvar = "{:s}开工资{:.2f}元,买了{:d}个兰博基尼".format("孙坚",300000.12345,10)
print(strvar)

2. 字符串相关的方法

字符串的相关函数

# *capitalize 字符串首字母大写 
strvar = "how are you"
res = strvar.capitalize()
print(res)
# *title 每个单词的首字母大写 
strvar = "how old are you"
res = strvar.title()
print(res)
# *upper 将所有字母变成大写
strvar = "How Old Are You"
res = strvar.upper()
print(res)
# *lower 将所有字母变成小写 
res = strvar.lower()
print(res)
# *swapcase 大小写互换 
strvar = "How old Are You"
res = strvar.swapcase()
print(res)
# *len 计算字符串的长度 
strvar = "python32真热"
res = len(strvar)
print(res)
# *count 统计字符串中某个元素的数量 
"""count(字符,[开始值,结束值])"""
strvar = "真热真热呀"
# res = strvar.count("真")     # 2
# res = strvar.count("热",2)   # 1
# res = strvar.count("热",2,3) # 只有真这个字符 没有热
print(res)
# *find 查找某个字符串第一次出现的索引位置  (推荐)
"""find(字符,[开始值,结束值])"""
strvar = "To be or not to be that is a question"
res = strvar.find("to")
res = strvar.find("be",4)
# 如果find 返回的是 -1 代表没找到
res = strvar.find("be",4,10) # 4 ~ 9
print(res)
# *index 与 find 功能相同 find找不到返回-1,index找不到数据直接报错
"""
res = strvar.index("be",4,10) 
print(res)
"""
# *startswith 判断是否以某个字符或字符串为开头 
"""
startswith(字符,[开始值,结束值])
endswith(字符,[开始值,结束值])
"""
strvar = "To be or not to be that is a question"
res = strvar.startswith("To")
res = strvar.startswith("To",10)
print(res)
# *endswith 判断是否以某个字符或字符串结尾 
res = strvar.endswith("question")
res = strvar.endswith("is",-14,-11) #  is
print(res)

# ### is系列
# *isupper 判断字符串是否都是大写字母 
strvar = "HOW  A  YOU"
res = strvar.isupper()
print(res)
# *islower 判断字符串是否都是小写字母 
strvar = "asdf - as"
res = strvar.islower()
print(res)
# *isdecimal 检测字符串是否以数字组成  必须是纯数字
strvar = "abcdefg"
strvar = "2134234.123"
strvar = "2134234"
res = strvar.isdecimal()
print(res)

# *split 按某字符将字符串分割成列表(默认字符是空格)  ***
strvar = "you can you up no can no bb"
lst = strvar.split()
strvar = "you#can#you#up#no#can#no#bb"
lst = strvar.split("#")
print(lst)
# *join  按某字符将列表拼接成字符串(容器类型都可)    ***
lst = ['you', 'can', 'you', 'up', 'no', 'can', 'no', 'bb']
strvar = " ".join(lst)
strvar = "#".join(lst)
print(strvar)
# *replace 把字符串的旧字符换成新http://www.cppcns.com字符  ***
"""字符串.replace('旧字符','新字符'[, 限制替换的次数])"""
strvar = "范冰冰爱不爱我,爱我,不爱我,爱我,不爱我"
res = strvar.replace("不爱我","爱我")
# 选择替换的次数
res = strvar.replace("不爱我","爱我",1)
print(res)
# *strip  默认去掉首尾两边的空白符  ***
"""空白符 空格 \n \t \r ... """
strvar = "     周润发  "
res = strvar.strip()
print(strvar)
print(res)
# *center 填充字符串,原字符居中 (默认填充空格)
"""center(字符长度,填充符号)"""
strvar = "赵世超"
res = strvar.center(10)
# res = strvar.center(10,"*")
print(res)

3. 列表的相关操作

列表的相关操作

# ### 列表的相关操作
lst1 = ["孟凡伟","康与众"]
lst2 = ["康与众","张宇"]
# (1)列表的拼接   (同元组)
res = lst1 + lst2
print(res)
# (2)列表的重复   (同元组)
res = lst1 * 3
print(res)
# (3)列表的切片   (同元组)
"""
语法 => 列表[::]  完整格式：[开始索引:结束索引:间隔值]
	(1)[开始索引:]  从开始索引截取到列表的最后
	(2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
	(3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
	(4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
	(5)[:]或[::]  截取所有列表
"""
lst = ["孟凡伟","康与众","张宇","赵沈阳","需保障","梁新宇","沈思雨"]
# (1)[开始索引:]  从开始索引截取到列表的最后
res =lst[2:]
print(res)
# (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
res =lst[:3]
print(res)
# (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
res = lst[3:5]
print(res)
# (4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
# 正向截取
res = lst[::5]
print(res) # 0 5 10
# 逆向截取
res = lst[::-3] # -1 -4 -7
print(res)
# (5)[:]或[::]  截取所有列表
res = lst[:]
res = lst[::]
print(res)
# (4)列表的获取   (同元组)
#       0  1  2
lst = [10,20,30]
#     -3  -2 -1
print(lst[-1])
# (5)列表的修改   ( 可切片 )
lst = ["孟凡伟","康与众","张宇","赵沈阳","需保障","梁新宇","沈思雨"]
# 改单个值
lst[1] = "陈璐"
print(lst)
# 1.改多个值 (如果使用切片进行修改,要求数据必须是Iterable可迭代性数据)
# lst[1:4] = ["孙悟空","猪八戒","白骨精"]
lst[1:4] = "你好"
print(lst)
# 2.改多个值(带有步长)
"""带有步长的切片修改,切出几个元素就修改几个元素,数量要一致."""
lst = ["孟凡伟","康与众","张宇","赵沈阳","需保障","梁新宇","沈思雨"]
"""0 3 6 """
lst[::3] = "abc"
# lst[::3] = "ab" error
print(lst)
# (6)列表的删除   ( 可切片 )
lst = ["孟凡伟","康与众","张宇","赵沈阳","需保障","梁新宇","沈思雨"]
# 1.一次删一个
# del lst[2]
# print(lst)
# 2.一次删一堆
# del lst[1:-1]
# print(lst)
# 3.注意点
res = lst[1:-1]
del res # 删除的是res这个变量 和 列表无关
print(lst)

# 额外的注意点
tup = (1,2,3,4,[10,11,12])
print(tup[-1])
tup[-1][-1] = 13
print(tup)

4. 列表的相关函数

列表相关的函数

# ### 列表相关的函数
# 增
# append 向列表的末尾添加新的元素
lst = ["赵沈阳"]
lst.append("沈思雨")
print(lst)
# insert 在指定索引之前插入元素
lst = ['赵沈阳', '沈思雨']
lst.insert(1,"王伟")
print(lst)
# extend 迭代追加所有元素
"""迭代追加的数据是可迭代性数据(容器类型数据,range对象,迭代器)"""
lst = ['赵沈阳', '沈思雨']
# tup = (1,2,3)
# lst.extend(tup)
# strvar = "abc"
# lst.extend(strvar)
lst.extend(range(3))
print(lst)
# 删
# 1.pop 通过指定索引删除元素,若没有索引移除最后那个 (推荐)
lst = ["曹静怡","王志国","邓鹏","合理"]
# 不指定下标,默认删除最后一个
res = lst.pop()
print(res)
print(lst)
# 指定下标,删除具体某个元素
res = lst.pop(1)
print(res)
print(lst)
# 2.remove 通过给予的值来删除,如果多个相同元素,默认删除第一个
lst = ["曹静怡","王志国","合理","邓鹏","合理"]
res = lst.remove("合理")
print(res)
print(lst)
# 3.clear 清空列表
lst = ["曹静怡","王志国","合理","邓鹏","合理"]
lst.clear()
print(lst)
# 改查 参考4.py
# 列表的其他相关函数
# index 获取某个值在列表中的索引
lst = ["曹静怡","王志国","合理","邓鹏","合理","邓鹏辉","邓鹏蓝","合理","邓鹏绿"]
res = lst.index("合理")
res = lst.index("合理",3)
res = lst.index("合理",3,6) # 3 4 5
# res = lst.index("合理大") error
print(res)
# count 计算某个元素出现的次数
res = lst.count("合理") # 没有范围的概念
print(res)
# sort 对列表排序
lst = [-90,-100,-1,90,78]
# 从小到大进行排序
lst.sort()
# 从大到小进行排序
lst.sort(reverse=True)
print(lst)
# 对字符串进行排序(按照ascii编码)
lst = ["kobi","james","jordon","yaoming","yi"]
lst.sort()
print(lst)
# 是否可以对中文排序(了解 无规律可循)
lst = ["王文","蔡徐坤"]
lst.sort()
print(lst)
# reverse 列表反转操作
lst = [1,2,"a","蔡徐坤","易烊千玺"]
lst.reverse()
print(lst)

5. 深浅拷贝

列表的深浅拷贝

# ### 列表的深浅拷贝
"""
a = 100
b = a
a = 200
print(b)
lst1 = [1,2,3]
lst2 = lst1
lst1.append(4)
print(lst2)
"""
# 1.浅拷贝
import copy
"""模块.方法() 同名模块下的同名方法"""
# 方法一 (推荐)
"""
lst1 = [1,2,3]
lst2 = copy.copy(lst1)
lst1.append(10)
print(lst2)
print(lst1)
"""
# 方法二
"""
lst1 = [1,2,3]
lst2 = lst1.copy()
lst1.append(11)
print(lst1)
print(lst2)
"""
# 2.深拷贝
"""把所有层级的容器元素都单独拷贝一份,放到独立的空间中"""
"""
# 现象
lst1 = [1,2,3,[4,5,6]]
lst2 = copy.copy(lst1)
lst1[-1].append(77)
lst1.append(8888)
print(lst2)
print(lst1)
"""
import copy
lst1 = [1,2,3,[4,5,6]]
lst2 = copy.deepcopy(lst1)
lst1[-1].append(999)
print(lst2)
print(lst1)

# 其他容器的深拷贝
lst1 = (1,2,3,{"a":1,"b":[10,20]})
lst2 = copy.deepcopy(lst1)
lst1[-1]["b"].append(30)
print(lst1)
print(lst2)
"""
总结:
浅拷贝:
	只拷贝一级容器中的所有元素独立出一个单独的空间.
深拷贝:
	把所有层级的容器中所有元素都单独拷贝一份,形成独立的空间
"""
"""
tuple 只有count  index 两个方法 使用同列表
"""

小提示：

:d 强制接收的数据为整型，如果不是整型则报错
# 会报错，因为9.5是小数
strvar = "刘一峰昨天晚上买了%d个花露水泡脚".formar(9.5)
print(strvar)
# 不报错，3.88会强转成int类型为3
strvar = "刘一峰昨天晚上买了%d个花露水泡脚" % (3.88)
print(strvar)
isdecimal 
strvar = "123.34"
res = strvar.isdecimal()
print(res) 这个值是False，因为.会认为不是一个数字
"123" 这个才会认为是纯数字

6. 小练习

（1）字符串相关练习问题：

# ### 字符串相关练习
1.有变量name = "aleX leNb" 完成如下操作：
移除 name 变量对应的值两边的空格,并输出处理结果
1)移除name变量左边的"al"并输出处理结果
2)移除name变量右面的"Nb",并输出处理结果
3)移除name变量开头的a与最后的"b",并输出处理结果
4)判断 name 变量是否以 "al" 开头,并输出结果
5)判断name变量是否以"Nb"结尾,并输出结果
6)将 name 变量对应的值中的 所有的"l" 替换为 "p",并输出结果 
7)将name变量对应的值中的第一个"l"替换成"p",并输出结果
8)将 name 变量对应的值根据 所有的"l" 分割,并输出结果。
name = "aleX leNb"
res = name.split('l')
print(res)
9)将name变量对应的值根据第一个"l"分割,并输出结果。 
10)将 name 变量对应的值变大写,并输出结果
11)将 name 变量对应的值变小写,并输出结果
12)将name变量对应的值首字母"a"大写,并输出结果
13)判断name变量对应的值字母"l"出现几次，并输出结果
14)如果判断name变量对应的值前四位"l"出现几次,并输出结果
15)从name变量对应的值中找到"N"对应的索引(如果找不到则报错)，并输出结果
16)从name变量对应的值中找到"N"对应的索引(如果找不到则返回-1)输出结果
17)从name变量对应的值中找到"X le"对应的索引,并输出结果
18)请输出 name 变量对应的值的第 2 个字符? 
19)请输出 name 变量对应的值的前 3 个字符? 
20)请输出 name 变量对应的值的后 2 个字符?
21)请输出 name 变量对应的值中 "e" 所在索引位置?
2.实现一个整数加法计算器(两个数相加)：
如：content = input("请输入内容:") 用户输入：5+9或3+ 9或5 + 6，然后进行分割再进行计算
3.升级题：实现一个整数加法计算器（多个数相加）：
如：content = input("请输入内容:") 用户输入：5+9+6 +12+  13，然后进行分割再进行计算。
4.计算用户输入的内容中有几个整数（以个位数为单位）。
如：content = input("请输入内容：")   # 如fhdal234slfh98769fjdla
5.等待用户输入内容，是否包含敏感字符？
如果存在敏感字符提示“存在敏感字符请重新输入”，敏感字符：“粉嫩”、“铁锤”

6.制作趣味模板程序需求：等待用户输入名字、地点、爱好
拼装数据打印出：敬爱可亲的xxx，最喜欢在xxx地方xxx

字符串相关练习答案：

# ### 字符串相关练习
# 1.有变量name = "aleX leNb" 完成如下操作：
name = "aleX leNb"
# 移除 name 变量对应的值两边的空格,并输出处理结果
name.strip()
# 1)移除name变量左边的"al"并输出处理结果
name.lstrip("al")
# 2)移除name变量右面的"Nb",并输出处理结果
name.rstrip("Nb")
# 3)移除name变量开头的a与最后的"b",并输出处理结果
print(name[1:-1])
# 4)判断 name 变量是否以 "al" 开头,并输出结果
res = name.startswith("al")
print(res)
# 5)判断name变量是否以"Nb"结尾,并输出结果
res = name.endswith("Nb")
print(res)
# 6)将 name 变量对应的值中的 所有的"l" 替换为 "p",并输出结果 
res = name.replace("l","p")
print(res)
# 7)将name变量对应的值中的第一个"l"替换成"p",并输出结果
res = name.replace("l","p",1)
print(res)
# 8)将 name 变量对应的值根据 所有的"l" 分割,并输出结果。
res = name.split("l")
print(res) 
# 9)将name变量对应的值根据第一个"l"分割,并输出结果。 
# 字符串.split("分割的字符",分割的次数)
# 从左向右
print(name.split("l",1))
strvar = "you-can-you-up"
# 从右向左
print(strvar.rsplit("-",2))
# 10)将 name 变量对应的值变大写,并输出结果
name.upper()
# 11)将 name 变量对应的值变小写,并输出结果
name.lower()
# 12)将name变量对应的值首字母"a"大写,并输出结果
print(name.capitalize())
# 13)判断name变量对应的值字母"l"出现几次，并输出结果
print(name.count("l"))
# 14)如果判断name变量对应的值前四位"l"出现几次,并输出结果
print(name.count("l",0,4))
# 15)从name变量对应的值中找到"N"对应的索引(如果找不到则报错)，并输出结果
print(name.index("N"))
# 16)从name变量对应的值中找到"N"对应的索引(如果找不到则返回-1)输出结果
print(name.find("N"))
# 17)从name变量对应的值中找到"X le"对应的索引,并输出结果
print(name.find("X le"))
# 18)请输出 name 变量对应的值的第 2 个字符?
print(name[1] )
# 19)请输出 name 变量对应的值的前 3 个字符? 
print(name[:3])
# 20)请输出 name 变量对应的值的后 2 个字符?
print(name[-2:])
# 21)请输出 name 变量对应的值中 "e" 所在索引位置?
name = "aleX leNb"
print(name.find("e"))
print("<=====>")
for i in range(len(name)):
	if name[i] == "e":print(i)

# 2.实现一个整数加法计算器(两个数相加)：
# 如：content = input("请输入内容:") 用户输入：5+9或3+ 9或5 + 6，然后进行分割再进行计算
"""
content = input("请输入内容:") 
print(content)
a,b = content.split("+")
print( a,b )
print(float(a.strip()) + float(b.strip()))
"""
# 3.升级题：实现一个整数加法计算器（多个数相加）：
# 如：content = input("请输入内容:") 用户输入：5+9+6 +12+  13，然后进行分割再进行计算。
"""
content = input("请输入内容:") 
print(content)
lst = content.split("+")
print(lst)
total = 0
for i in lst:
	total += float(i.strip())
print(total)
"""
# 4.计算用户输入的内容中有几个整数.
# 如：content = input("请输入内容：")   # 如fhdal234slfh98769fjdla
"""
content = input("请输入内容：")
total = 0
for i in content:
	if i.isdecimal():
		total += 1
print(total)
"""
# 5.等待用户输入内容，是否包含敏感字符？
# 如果存在敏感字符提示“存在敏感字符请重新输入”，敏感字符：“粉嫩”、“铁锤”
# 方法一
'''
lst = ["粉嫩","铁锤"]
while True:
	# 重置sign标记
	sign = False
	content = input("请输入内容：")
	# print(content)
	"""
	if content.find("粉嫩") == -1 and content.find("铁锤") == -1:
		print("ok")
	else:
		print("not ok")
	"""
	# 小分铁嫩锤
	for i in lst:
		if i in content:	
			# 把sign标记设置成True
			sign = True
			break
	# 如果sign 这个标记是True,敏感,否则不敏感;
	if sign == True:
		print("存在敏感字符请重新输入")
	else:
		print("不存在敏感字符")
		break
'''
print("<====>")
# 方法二 (python特有) 额外的
"""如果在循环时,遇到break临时终止了循环,else这个分支不执行的
只有在正常全部循环执行了一遍之后,才会执行else分支
"""
"""
for i in range(3):
	if i == 2:
		break
else:
	print("ok")
"""

"""
lst = ["粉嫩","铁锤"]
# 触发break,不执行else , 不触发break , 执行else
while True:
	content = input("请输入内容：")
	for i in lst:
		# 但凡发现了敏感词汇,直接break,就不会走else分支了
		if i in content:
			print("是敏感词汇,请重新输入")
			# 终止内层的for循环
			break
	else:
		print("不是敏感词汇")
		# 终止外层while循环
		break
"""


# 6.制作趣味模板程序需求：等待用户输入名字、地点、爱好
# 拼装数据打印出：敬爱可亲的xxx，最喜欢在xxx地方xxx
while True:	
	name = input("请输入姓名:  按q可以退出~")
	if name.upper() == "Q":
		print("欢迎老铁下次来玩~")
		break
	place = input("请输入地点:")
	hobby = input("请输入爱好:")
	print("敬爱可亲的{}，最喜欢在{}地方{}".format(name,place,hobby))

（2）列表相关练习问题：

# ### 列表相关练习
1.li = ["alex", "WuSir", "xboy", "oldboy"]
1)列表中追加元素"seven",并输出添加后的列表
2)请在列表的第1个位置插入元素"Tony",并输出添加后的列表
3)请修改列表第2个位置的元素为"Kelly",并输出修改后的列表
4)请将列表l2=[1,"a",3,4,"heart"]的每一个元素添加到列表li中，一行
代码实现，不允许循环添加。
5)请将字符串s = "qwert"的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
6)请删除列表中的元素"alex",并输出添加后的列表
7)请删除列表请删除列表中的第2至4个元素，并输出删除元素后的列表
8)删除列表中的第2个元素，并输出删除的元素和删除元素后的列表
9)请将列表所有得元素反转，并输出反转后的列表
10)请计算出"alex"元素在列表li中出现的次数，并输出该次数。
2，写代码，有如下列表，利用切片实现每一个功能
li = [1, 3, 2, "a", 4, "b", 5,"c"]
1)通过对li列表的切片形成新的列表l1,l1 = [1,3,2]
2)通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
3)通过对li列表的切片形成新的列表l3,l3 = ["1,2,4,5]
4)通过对li列表的切片形成新的列表l4,l4 = [3,"a","b"]
5)通过对li列表的切片形成新的列表l5,l5 = ["c"]
6)通过对li列表的切片形成新的列表l6,l6 = ["b","a",3]
3,写代码，有如下列表，按照要求实现每一个功能。
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
1)将列表lis中的"tt"变成大写。
2)将列表中的数字3变成字符串"100"。
3)将列表中的字符串"1"变成数字101
4,li = ["alex", "eric", "rain"]   
利用下划线将列表的每一个元素拼接成字符串"alex_eric_rain"
5.利用for循环打印出下面列表的索引。
li = ["alex", "Wu编程客栈Sir", "xboy", "oldboy"]
6.利用for循环和range 找出50以内能被3整除的数，并将这些数插入到一个新列表中。
7.利用for循环和range从100~10，倒序将所有的偶数添加到一个新列表中，然后对列表的元素进行筛选，将能被4整除的数留下来
8.查找列表li中的元素，移除每个元素的空格，并找出以"A"或者"a"开头，并以"c"结尾的所有元素，并添加到一个新列表中,最后循环打印这个新列表。
li = ["xboy ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", "  aqc"]
9.敏感词列表 li = ["张三", "李四", "王二", "麻子"]
将用户输入的内容中的敏感词汇替换成等长度的*（张三就替换***），并添加到一个列表中；如果用户输入的内容没有敏感词汇，则直接添加到新列表中。
10.li = [1, 3, 4, "alex", [3, 7, “23aa”,8, "xboy"], 5,(‘a','b')]
循环打印列表中的每个元素,并转化为小写，遇到列表则再循环打印出它里面的元素。

11.tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
a.讲述元组的特性
b.请问tu变量中的第一个元素 "alex" 是否可被修改？
c.请问tu变量中的"k2"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素 "Seven"
d.请问tu变量中的"k3"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素 "Seven"

列表相关练习答案：

# ### 列表相关练习
# 1.li = ["alex", "WuSir", "xboy", "oldboy"]
li = ["alex", "WuSir", "xboy", "oldboy"]
# 1)列表中追加元素"seven",并输出添加后的列表
li.append("seven")
# 2)请在列表的第1个位置插入元素"Tony",并输出添加后的列表
li.insert(0,"Tony")
# 3)请修改列表第2个位置的元素为"Kelly",并输出修改后的列表
li[1] = "Kelly"
# 4)请将列表l2=[1,"a",3,4,"heart"]的每一个元素添加到列表li中，一行
# 代码实现，不允许循环添加。
l2=[1,"a",3,4,"heart"]
li.extend(l2)
print(li)
# 5)请将字符串s = "qwert"的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
s = "qwert"
li.extend(s)
print(li)
# 6)请删除列表中的元素"Tony",并输出添加后的列表
li.remove("Tony")
print(li)
# 7)请删除列表中的第2至4个元素，并输出删除元素后的列表
# del li[1:4]
# print(li)
# 8)删除列表中的第2个元素，并输出删除的元素和删除元素后的列表
res = li.pop(1)
print(res)
print(li)
# 9)请将列表所有得元素反转，并输出反转后的列表
li.reverse()
print(li)
# 10)请计算出"alex"元素在列表li中出现的次数，并输出该次数。
print(li.count("xboy"))

# 2，写代码，有如下列表，利用切片实现每一个功能
li = [1, 3, 2, "a", 4, "b", 5,"c"]
# 1)通过对li列表的切片形成新的列表l1,l1 = [1,3,2]
print(li[:3])
# 2)通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
print(li[3:6])
# 3)通过对li列表的切片形成新的列表l3,l3 = ["1,2,4,5]
print(li[::2])
# 4)通过对li列表的切片形成新的列表l4,l4 = [3,"a","b"]
print(li[1:-1:2])
# 编程客栈5)通过对li列表的切片形成新的列表l5,l5 = ["c"]
print(li[-1:])
# 6)通过对li列表的切片形成新的列表l6,l6 = ["b","a",3]
print(li[-3::-2])

# 3,写代码，有如下列表，按照要求实现每一个功能。
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
# 1)将列表lis中的"tt"变成大写。
print(lis[3][2][1][0].upper())
# 2)将列表中的数字3变成字符串"100"。
lis[3][2][1][1] = "100"
# 3)将列表中的字符串"1"变成数字101
# lis[3][2][1][-1] = 101
# print(lis)
lis[3][2][1].remove("1") # 先删
lis[3][2][1].append(101) # 在增
print(lis)

# 4,
li = ["alex", "eric", "rain"]   
# 利用下划线将列表的每一个元素拼接成字符串"alex_eric_rain"
# 一
print("_".join(li))
# 二
strvar = ""
for i in li:
	strvar += i + "_"
print(strvar.rstrip("_"))

# 5.利用for循环打印出下面列表的索引。
li = ["alex", "WuSir", "xboy", "oldboy"]
# 一
for i in range(len(li)):
	print(i)
# 二
for i in li:
	print(li.index(i))

# 6.利用for循环和range 找出50以内能被3整除的数，并将这些数插入到一个新列表中。
a = []
for i in range(50):
	if i % 3 == 0 :
		a.append(i)
print(a)
# 7.利用for循环和range从100~10，倒序将所有的偶数添加到一个新列表中，然后对列表的元素进行筛选，将能被4整除的数留下来
a = []
for i in range(100,9,-2):
	if i % 4 == 0:
		a.appen编程客栈d(i)	
print(a)

# 8.查找列表li中的元素，移除每个元素的空格，并找出以"A"或者"a"开头，并以"c"结尾的所有元素，并添加到一个新列表中,最后循环打印这个新列表。
li = ["xboy ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", "  aqc"]
lst2 = []
for j in li:
	if (j.strip().startswith("A") or j.strip().startswith("a")) and j.strip().endswith("c"):
		lst2.append(j.strip())
print(lst2)

# 9.敏感词列表 li = ["张三", "李四", "王二", "麻子"]
# 将用户输入的内容中的敏感词汇替换成等长度的*（张三就替换***），并添加到一个列表中；如果用户输入的内容没有敏感词汇，则直接添加到新列表中。
li = ["张三", "李四", "王二", "麻子"]
lst = []
"""
while True:
	strvar = input("请输入词汇:")
	lst.append(strvar.replace("张三","***").replace("李四","***").replace("王二","***").replace("麻子","*****"))
	print(lst)
"""
"""
while True:
	strvar = input("请输入词汇:")
	# 按q退出
	if strvar.upper() == "Q":
		break
	# 过滤敏感词汇
	for i in li:
		if i in strvar:
			strvar = strvar.replace(i,len(i) * "*")
	# 把处理数据放到列表中
	lst.append(strvar)
print(lst)
"""

# 10.
print("<====>")
li = [1, 3, 4, "ALEx", [3, 7, "23AA",8, "XBoy"], 5,("A","b")]
# 循环打印列表中的每个元素,并转化为小写，遇到列表则再循环打印出它里面的元素。
for i in li:
	# 判断是否是字符串
	if isinstance(i,str):
		print(i.lower())
	# 判断是否是Number
	elif isinstance(i,(int,bool,complex,float)):
		print(i)
	# 判断是否是容器
	elif isinstance(i,(list,tuple,set,dict)):
		for j in i:
			# 判断容器中的元素是不是字符串
			if isinstance(j,str):
				print(j.lower())
			# 不是的话直接输出即可
			else:
				print(j)

11.tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
# a.讲述元组的特性
可获取 , 不可修改 , 有序
# b.请问tu变量中的第一个元素 "alex" 是否可被修改？ 不可以
# c.请问tu变量中的"k2"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素 "Seven"
列表 能改 tu[1][2]["k2"].append("Seven")
# d.请问tu变量中的"k3"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素 "Seven"
元组,不行,

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注我们的更多内容!