开发者

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 两个方法 使用同列表
          """
          

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

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

          小提示:

          :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"
          元组,不行,
          

          总结

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

          0

          上一篇:

          下一篇:

          精彩评论

          暂无评论...
          验证码 换一张
          取 消

          最新开发

          开发排行榜