字符串的相关操作

1.字符串的拼接

  1. 1 strvar = "vegeta"+"ble"
  2. 2 print(strvar) # vegetable

2.字符串的重复

 1 strvar = “good“ * 3

3.字符串的跨行拼接 使用\

  1. 1 strvar = "abcdefghijklmnopqrst" \
  2. 2 "uvwxyz"
  3. 3 print(strvar) # abcdefghijklmnopqrstuvwxyz

4.字符串的索引

  1. 1 '''
  2. 2 正向索引 0123
  3. 3 strvar = "1234"
  4. 4 逆向索引 -4-3-2-1
  5. 5 '''

5.字符串的切片

注意: [开始索引:结束索引:间隔值]

res = strvar[::2] # 0 2 4 6 8….. 从开始截取到最后

res = strvar[::-1] # -1 -2 -3 -4 -5 -6….. 从结尾截取到最前

  1.  1 # [开始索引:]  从开始索引截取到字符串的最后
  2.  2 strvar="红橙黄绿青蓝紫"
  3.  3 res = strvar[4:]
  4.  4 print(res) 
  5.  5 
  6.  6 # [:结束索引]  从开头截取到结束索引之前(结束索引-1)
  7.  7 res = strvar[:5]
  8.  8 print(res)
  9.  9 
  10. 10 # [开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
  11. 11 res = strvar[1:3]
  12. 12 print(res)
  13. 13 
  14. 14 # [开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取字符
  15. 15 # 正序
  16. 16 res = strvar[::2] # 0 2 4 6 8..... 从开始截取到最后
  17. 17 print(res)
  18. 18 # 倒序
  19. 19 res = strvar[::-1] # -1 -2 -3 -4 -5 -6.....
  20. 20 print(res)
  21. 21 
  22. 22 # [:]或[::]  截取所有字符串
  23. 23 res1 = strvar[:]
  24. 24 res2 = strvar[::]
  25. 25 print(res1)
  26. 26 print(res2)

————————————————————————-

字符串的方法

常规：

  1.  1 # capicalize 字符串首字母大写
  2.  2 strvar ="what is your name"
  3.  3 res = strvar.capitalize()
  4.  4 print(res) # What is your name
  5.  5 
  6.  6 # title 每个单词的首字母大写
  7.  7 strvar ="what is your name"
  8.  8 res = strvar.title()
  9.  9 print(res) # What Is Your Name
  10. 10 
  11. 11 # upper 将所有字母变成大写
  12. 12 strvar ="what is your name"
  13. 13 res = strvar.upper()
  14. 14 print(res) # WHAT IS YOUR NAME
  15. 15 
  16. 16 # lower 将所有字母变成小写
  17. 17 strvar = "HELLO KITTY"
  18. 18 res = strvar.lower()
  19. 19 print(res) # hello kitty
  20. 20 
  21. 21 # swapcase 大小写互换
  22. 22 strvar = "AAAAbbbb"
  23. 23 res = strvar.lower()
  24. 24 print(res) # aaaaBBBB
  25. 25 
  26. 26 # len 计算字符串的长度
  27. 27 strvar = "AAAAbbbb"
  28. 28 res = len(strvar)
  29. 29 print(res) # 8
  30. 30 
  31. 31 # count 统计字符串中某个元素的数量
  32. 32 strvar = "AAAAbbbb"
  33. 33 res = strvar.count("A")
  34. 34 print(res) # 4
  35. 35 
  36. 36 # find  查找某个字符串第一次出现的索引位置(推荐使用)
  37. 37 '''字符串.find("字符",开始索引,结束索引) 如果找不到直接返回-1'''
  38. 38 strvar = "abcdefabc"
  39. 39 res = strvar.find("a") # 0
  40. 40 res = strvar.find("a",2) # 6
  41. 41 res = strvar.find("d",2,5) # 3 结束索引本身取不到，取到之前的那个值
  42. 42 print(res)
  43. 43 
  44. 44 # index与find功能相同，find找不到返回-1，index找不到数据会报错
  45. 45 res = strvar.index("d",6,8) # error
  46. 46 
  47. 47 # startswith 判断是否以某个字符或字符串为开头
  48. 48 '''
  49. 49 字符串.startswith("字符串",开始索引,结束索引) 
  50. 50 如果存在返回True，否则返回False
  51. 51 '''
  52. 52 strvar = "abcdefg"
  53. 53 res = strvar.startswith("a") # True
  54. 54 res = strvar.startswith("b",1) # True
  55. 55 res = strvar.startswith("c",2,5) # True  2 3 4
  56. 56 print(res)
  57. 57 
  58. 58 # endswith 判断是否以某个字符或字符串结尾
  59. 59 res = strvar.endswith("g") # True
  60. 60 res = strvar.endswith("g",-6) # True
  61. 61 res = strvar.endswith("d",-6,-3) # True
  62. 62 print(res)

is系列:

  1.  1 # isupper 判断字符串是否都是大写字母
  2.  2 strvar = "ABCD"
  3.  3 res = strvar.isupper()
  4.  4 print(res) # True
  5.  5 
  6.  6 # islower 判断字符串是否都是小写字母
  7.  7 strvar = "abcd123"
  8.  8 res = strvar.isupper()
  9.  9 print(res) # True
  10. 10 
  11. 11 # isdecimal 检测字符串是否以数字组成 必须是纯数字
  12. 12 strvar = "12345"
  13. 13 strvar = "123.4567"
  14. 14 res = strvar.isdecimal()
  15. 15 print(res)

填充/去除:

  1.  1 strvar = "abc"
  2.  2 # ljust 填充字符串，原字符居左(默认填充空格)
  3.  3 res = strvar.ljust(10)
  4.  4 print(res)
  5.  5 # rjust 填充字符串，原字符居右(默认填充空格)
  6.  6 res = strvar.rjust(10)
  7.  7 print(res)
  8.  8 # center 填充字符串，原字符居中(默认填充空格)
  9.  9 res = strvar.center(10) # 原字符串长度+填充字符长度=10，默认填充空格
  10. 10 res = strvar.center(10,"#")
  11. 11 print(res)
  12. 12 
  13. 13 # strip 默认去掉首尾两边的空白符
  14. 14 strvar = "####abcd####"
  15. 15 res = strvar.strip("#") # 指定去掉的符号 
  16. 16 print(res)
  17. 17 # rstrip 去掉右边某个字符
  18. 18 print(strvar.rstrip("#"))
  19. 19 # rstrip 去掉左边某个字符
  20. 20 print(strvar.lstrip("#"))

字符串最重要的三个方法：

  1.  1 # split 按某字符将字符串分割成列表(默认字符是空格)
  2.  2 strvar = "one two three four"
  3.  3 lst = strvar.split()
  4.  4 strvar= "one-two-three-four"
  5.  5 lst = strvar.split("-") # 从左到右分隔
  6.  6 lst = strvar.rsplit("-",2) # 从右到左分隔，可以指定分隔的次数
  7.  7 print(lst)
  8.  8 
  9.  9 # join 按某字符将列表拼接成字符串
  10. 10 lst = ['five','six','seven','eight']
  11. 11 res = "-".join(lst)
  12. 12 print(res)
  13. 13 
  14. 14 # replace 替换，把字符串的旧字符替换成新字符
  15. 15 '''replace(要替换的字符,替换成什么,替换的次数)'''
  16. 16 strvar = "这只小狗真可爱，真呀真可爱"
  17. 17 res = strvar.replace("可爱","有趣")
  18. 18 res = strvar.replace("可爱","有趣",1)
  19. 19 print(res)

———————————————————————————–

字符串的格式化:

  1. # 1.顺序传参
  2. strvar = "{}喜欢吃{}".format("我","苹果")
  3. print(strvar)
  5. # 2.索引传参
  6. strvar = "{1}喜欢吃{0}".format("苹果","我")
  7. print(strvar)
  9. # 3.关键字传参
  10. strvar = "{thing2}喜欢吃{thing1}".format(thing1="苹果",thing2="我")
  11. print(strvar)
  13. # 4.容器类型数据(列表或元组传参)
  14. strvar = "{0[2]}喜欢吃{1[1]}".format(["小红","小明","小刚"],("苹果","香蕉","菠萝"))
  15. print(strvar)
  17. # format当中，不能使用逆向下标，不识别
  18. strvar = "{0[-1]}喜欢吃{1[-1]}".format(["小红","小明","小刚"],("苹果","香蕉","菠萝"))
  19. print(strvar)
  21. # 如果容器是字典
  22. strvar="{group1[xiaoming]}喜欢吃{group2[0]}".format(group1={"xiaohong":"小红","xiaoming":"小明"},group2=("香蕉","苹果"))
  23. print(strvar)

format 填充符号的使用和转换成特殊符号的使用:

  1.  1 #  format的填充符号的使用(^ < >)
  2.  2 """
  3.  3 ^ 原字符串居中
  4.  4 < 原字符串居左
  5.  5 > 原字符串居右
  6.  6 
  7.  7 {who:*^10}
  8.  8 who:关键字参数
  9.  9 *:要填充的字符
  10. 10 ^:原字符串居中
  11. 11 10:总长度=原字符串长度+填充字符长度
  12. 12 """
  13. 13 
  14. 14 strvar = "{who:*^10}在{where:>>10}吃{what:!<10}".format(who="我",where="别人家",what="苹果")
  15. 15 print(strvar)
  16. 16 
  17. 17 # 进制转换成特殊符号的使用( :d :f :s :,)
  18. 18 
  19. 19 # :d 整型占位符 要求类型必须是整型
  20. 20 strvar = "我吃了{:d}个苹果".format(3) #3.5 error
  21. 21 # :2d 占用两位，不够拿空格来补，默认居右
  22. 22 strvar = "我吃了{:2d}个苹果".format(3)
  23. 23 #  < > ^ 调整对应的位置
  24. 24 strvar = "我吃了{:<2d}个苹果".format(3)
  25. 25 strvar = "我吃了{:<3d}个苹果".format(3)
  26. 26 print(strvar)
  27. 27 
  28. 28 # :f 浮点型占位符(要求类型必须是浮点型)
  29. 29 strvar = "我的成绩是{:f}".format(96.25)
  30. 30 # .2f 小数点保留两位
  31. 31 strvar = "我的成绩是{:.2f}".format(96.25)
  32. 32 print(strvar)
  33. 33 
  34. 34 # :s 字符串占位符 (要求类型必须是字符串)
  35. 35 strvar = "{:s}".format("啦啦啦啦啦")
  36. 36 print(strvar)
  37. 37 
  38. 38 # :, 金钱占位符
  39. 39 strvar = "{:,}".format(3256224583)
  40. 40 print(strvar)
  41. 41 
  42. 42 # 综合案例
  43. 43 strvar = "我今年{:d}岁,我的语文分数是{:.1f},我心情{:s}".format(23,98.65,"非常好")
  44. 44 print(strvar)

列表的操作：

  1. # ### 列表的相关操作
  2.  
  3. # 1.列表的拼接(同元组)
  4. lst1 = [1,2,3]
  5. lst2 = [4,5,6,7,8,8]
  6. res = lst1 + lst2
  7. print(res)
  9. # 2.列表的重复(同元组)
  10. res = lst1 * 6
  11. print(res)
  13. # 3.列表的切片(同元组)
  14. # 语法:列表[::]  完整格式：[开始索引:结束索引:间隔值]
  15.     # (1)[开始索引:]  从开始索引截取到列表的最后
  16.     # (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
  17.     # (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
  18.     # (4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
  19.     # (5)[:]或[::]  截取所有列表
  20.     
  21. lst=["Alan","Cat","Sun","Wuming","Huahai","Mc","Orange","Rxy"]    
  22. # (1) [开始索引:]  从开始索引截取到列表的最后
  23. res = lst[3:]
  24. print(res)
  25. # (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
  26. res = lst[:6]
  27. print(res)
  28. # (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
  29. res = lst[3:6]
  30. print(res)
  31. # (4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
  32. # 正向截取
  33. res = lst[::2] 
  34. print(res)
  35. # 逆向截取
  36. res = lst[::-2] 
  37. print(res)
  38. # (5)[:]或[::]  截取所有列表
  39. res = lst[:]
  40. res = lst[::]
  41. print(res)
  42.     
  43.     
  44. # 4.列表的获取(同元组)
  45. #      0      1     2       3       4       5      6      7
  46. lst=["Alan","Cat","Sun","Wuming","Huahai","Mc","Orange","Rxy"]    
  47. #      -8    -7    -6      -5       -4     -3     -2      -1
  48.     
  49. res = lst[6]
  50. res = lst[-2]
  51. print(res)    
  52.     
  53. # 5.列表的修改(可切片)
  54. '''
  55. 要求的数据类型是:可迭代性数据(容器类型数据,range对象,迭代器)
  56. '''
  58. lst=["Alan","Cat","Sun","Wuming","Huahai","Mc","Orange","Rxy"]    
  59. # 利用切片可以一次修改多个元素，没有个数上的限制
  60. lst[1:3] = "abcdef" 
  61. print(lst)
  63. # 切片配合步长,切出多少个元素，修改多少个元素
  64. lst=["Alan","Cat","Sun","Wuming","Huahai","Mc","Orange","Rxy"]    
  65. res = lst[::2] # Alan Sun Huahai Orange
  66. lst[::2] = range(1,5)
  67. print(lst)
  69. # 6.列表的删除
  70. lst=["Alan","Cat","Sun","Wuming","Huahai","Mc","Orange","Rxy"]    
  71. del lst[-1]
  72. print(lst)
  74. # 删除的是变量res本身，不是列表中的元素
  75. '''
  76. res = lst[-1]
  77. del res
  78. print(lst)
  79. '''
  80.  
  81. # del lst[:2]
  82. del lst[::3] #0 3 6 9 12...
  83. print(lst)
  85. # 元组中的列表,里面的元素可以修改;
  86. tup = (1,2,3,[4,5,6,(7,8,9)])
  87. tup[-1][1] = 66
  88. print(tup)

 

版权声明：本文为libolun原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/libolun/p/13296495.html