zoukankan      html  css  js  c++  java
  • day7:字符串的操作/方法&字符串的格式化format&列表的操作

    字符串的相关操作

    1.字符串的拼接

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

    2.字符串的重复

     1 strvar = "good" * 3

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

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

    4.字符串的索引

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

    5.字符串的切片

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

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

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

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

    -------------------------------------------------------------------------

    字符串的方法

    常规:

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

    is系列:

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

    填充/去除:

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

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

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

    -----------------------------------------------------------------------------------

    字符串的格式化:

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

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

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

    列表的操作:

    # ### 列表的相关操作
    
    # 1.列表的拼接(同元组)
    lst1 = [1,2,3]
    lst2 = [4,5,6,7,8,8]
    res = lst1 + lst2
    print(res)
    
    # 2.列表的重复(同元组)
    res = lst1 * 6
    print(res)
    
    # 3.列表的切片(同元组)
    # 语法:列表[::]  完整格式:[开始索引:结束索引:间隔值]
        # (1)[开始索引:]  从开始索引截取到列表的最后
        # (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
        # (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
        # (4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
        # (5)[:]或[::]  截取所有列表
        
    lst=["Alan","Cat","Sun","Wuming","Huahai","Mc","Orange","Rxy"]    
    # (1) [开始索引:]  从开始索引截取到列表的最后
    res = lst[3:]
    print(res)
    # (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
    res = lst[:6]
    print(res)
    # (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
    res = lst[3:6]
    print(res)
    # (4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
    # 正向截取
    res = lst[::2] 
    print(res)
    # 逆向截取
    res = lst[::-2] 
    print(res)
    # (5)[:]或[::]  截取所有列表
    res = lst[:]
    res = lst[::]
    print(res)
        
        
    # 4.列表的获取(同元组)
    #      0      1     2       3       4       5      6      7
    lst=["Alan","Cat","Sun","Wuming","Huahai","Mc","Orange","Rxy"]    
    #      -8    -7    -6      -5       -4     -3     -2      -1
        
    res = lst[6]
    res = lst[-2]
    print(res)    
        
    # 5.列表的修改(可切片)
    '''
    要求的数据类型是:可迭代性数据(容器类型数据,range对象,迭代器)
    '''
    
    lst=["Alan","Cat","Sun","Wuming","Huahai","Mc","Orange","Rxy"]    
    # 利用切片可以一次修改多个元素,没有个数上的限制
    lst[1:3] = "abcdef" 
    print(lst)
    
    # 切片配合步长,切出多少个元素,修改多少个元素
    lst=["Alan","Cat","Sun","Wuming","Huahai","Mc","Orange","Rxy"]    
    res = lst[::2] # Alan Sun Huahai Orange
    lst[::2] = range(1,5)
    print(lst)
    
    # 6.列表的删除
    lst=["Alan","Cat","Sun","Wuming","Huahai","Mc","Orange","Rxy"]    
    del lst[-1]
    print(lst)
    
    # 删除的是变量res本身,不是列表中的元素
    '''
    res = lst[-1]
    del res
    print(lst)
    '''
    
    # del lst[:2]
    del lst[::3] #0 3 6 9 12...
    print(lst)
    
    # 元组中的列表,里面的元素可以修改;
    tup = (1,2,3,[4,5,6,(7,8,9)])
    tup[-1][1] = 66
    print(tup)
  • 相关阅读:
    什么是P问题、NP问题和NPC问题
    Ubuntu 14.04 亮度BUG解决方案
    彻底理解Java中this指针
    Eclipse快捷键大全
    JAVA文件读写方法和性能比较总结
    Java下static关键字用法详解
    LeetCode: Gray Code
    LeetCode: 4sum
    LeetCode:3Sum Closest
    LeetCode:Remove Element
  • 原文地址:https://www.cnblogs.com/libolun/p/13296495.html
Copyright © 2011-2022 走看看