常用数据类型操作(二)

字符串


  • 概念:有序的 不可变的 字符集合

  • 形式

    • 转义字符
    转义字符 说明
    \t 水平制表符 tab
    \n 换行
    \r 回车
    \" 双引号
    \' 单引号
    \\ 反斜线
    • 非原始字符串
      # 使用单引号包含
      strOne = '王小熊'
      # 使用双引号包含
      strTwo = "秦子阳"
      # 使用 3 个单引号包含
      strThree = '''luck'''
      # 使用 3 个双引号包含
      strFour = """game"""
      
    • 原始字符串
      # 使用单引号包含
      strOne = r'coder'
      # 使用双引号包含
      strTwo = r"qinzy"
      # 使用 3 个单引号包含
      strThree = r'''87'''
      # 使用 3 个双引号包含
      strFour = r"""v5"""
      
    • 各个形式特点
      # 单/双引号:混合使用 可以避免使用 引号转义符
      nameStr = "my name is 'qin'"
      print(nameStr)
      
      # 跨行需要 续行符 或者 小括号
      nameStrOne = "我是" \
                   "王小熊" \
                   "87" \
                   "v5"
      print(nameStrOne)
      nameStrTwo = ("have "
                    "a "
                    "happy "
                    "day ")
      print(nameStrTwo)
      
      # 三个 单/双引号:可以直接跨行书写,可用于注释
      nameStrThree = """每个系统,在剥离了具体的表象之后,
      都存在着一个不能被删除或违反的逻辑基点,
      这是整个系统存在的前提。"""
      print(nameStrThree)
      
  • 常见操作

    • 字符串拼接
      # str1 + str2
      nameStr = "my name is " + "luck" 
      print(nameStr)
      
      # str1str2:直接把两个字符串放在一起
      nameStr = "coder""qinzy"
      print(nameStr)
      
      # "xxx%sxxx" % appendStr
      nameStr = "my name is %s" % "luck"
      print(nameStr)
      
      # str1 * n:字符串乘法
      nameStr = "王小熊\t" * 3
      print(nameStr)
      
    • 字符串切片
      1. 概念:获取一个字符串的某个片段
      
      2. 获取某一个字符
         1) name[下标]
         2) 下标:字符串中每个字符的编号
            * 负数下标:如果为负数,则会从尾部开始定位,最后一个字符为 -1
            ** 注意:下标越界
      
      3. 获取一个字符串片段
         1) name[start:end:step]
         2) 注意
            * 取值范围:包含 start,不包含 end
            ** 默认值:起始默认值为 0,结束默认值为 整个字符串长度,步长默认值为 1
            *** 获取顺序:步长 > 0,从左边到右边;步长 < 0,从右边到左边
         3) 反转字符串:str[::-1]
      
      nameStr = "coderqinzy"
      print(nameStr[::-1])
      print(nameStr[3:6:2])
      print(nameStr[-1:-4:-2])
      
    • 查找计算
      • len
         """
        作用:计算字符串的字符个数
        语法:len(str)
        参数:字符串
        返回值:整型,字符个数
        """
        nameStr = "王小熊"
        print(len(nameStr))
        
      • find
         """
        作用:查找子串索引位置
        语法:find(sub, start=0, end=len(str))
        参数:sub, 需要检索的字符串; 
             start, 检索的起始位置, 可省略, 默认 0; 
             end,检索的结束位置, 可省略, 默认len(str)
        返回值:找到了,指定索引,整型;找不到,-1
        注意:从左到右进行查找,找到后立即停止
        """
        nameStr = "xiao xiong"
        num = nameStr.find("xi", 5, 7)
        print(num)
        
      • rfind
        """
        功能使用, 同 find 一样
        区别:从右往左进行查找
        """
        nameStr = "xiao xiong"
        num = nameStr.rfind("xi")
        print(num)
        
      • index
        """
        作用:获取子串索引位置
        语法:index(sub, start=0, end=len(str))
        参数:sub, 需要检索的字符串; 
             start, 检索的起始位置, 可省略, 默认 0; 
             end, 检索的结束位置, 可省略, 默认len(str)
        返回值:找到了, 指定索引, 整型; 找不到, 异常
        注意:从左到右进行查找, 找到后立即停止
        """
        nameStr = "xiao xiong"
        num = nameStr.index("xi", 5, 7)
        print(num)
        
      • rindex
        """
        功能使用, 同 index 一样 
        区别:从右往左进行查找
        """
        nameStr = "xiao xiong"
        num = nameStr.rindex("xi")
        print(num)
        
      • count
        """
        作用:计算某个子串出现次数
        语法:count(sub, start=0, end=len(str))
        参数:sub, 需要检索的字符串; 
             start, 检索的起始位置, 可省略, 默认 0; 
             end, 检索的结束位置, 可省略, 默认len(str)
        返回值:子串出现次数,整型
        """
        nameStr = "xiao xiong"
        num = nameStr.count("xi", 5, 7)
        print(num)
        
    • 替代转换
      • replace
        """
        作用:使用给定的新字符串 替换 原字符串中的 旧字符串
        语法:replace(old, new[, count])
        参数:old, 需要被替换的旧字符串; 
             new, 替换后的新字符串; 
             count, 替换的个数, 可省略, 表示替换全部
        返回值:替换后的结果字符串
        注意:并不会修改原字符串本身
        """        
        nameStr = "xiao xiong"
        replaceStr = nameStr.replace("x", "w")
        print(replaceStr)
        
      • capitalize
        """
        作用:将字符串 首字母 变为 大写
        语法:capitalize()
        参数:无
        返回值:首字母大写后的新字符串
        注意:并不会修改原字符串本身
        """
        nameStr = "xiao xiong"
        capitalizeStr = nameStr.capitalize()
        print(capitalizeStr)
        
      • title
        """
        作用:将字符串 每个单词 的 首字母 变为 大写
        语法:title()
        参数:无
        返回值:每个单词首字母大写后的新字符串
        注意:并不会修改原字符串本身
        """
        nameStr = "xiao xiong*coder&qinzy_fish%apple"
        capitalizeStr = nameStr.title()
        print(capitalizeStr)
        
      • lower
        """
        作用:将字符串每个字符都变为小写
        语法:lower()
        参数:无
        返回值:全部变为小写后的新字符串
        注意:并不会修改原字符串本身
        """
        nameStr = "MY NAME IS WANG"
        lowerStr = nameStr.lower()
        print(lowerStr)
        
      • upper
        """
        作用:将字符串每个字符都变为大写
        语法:upper()   
        参数:无
        返回值:全部变为大写后的新字符串
        注意:并不会修改原字符串本身
        """
        nameStr = "my name is wang"
        upperStr = nameStr.upper()
        print(upperStr)
        
    • 填充压缩
      • ljust
        """
        作用:根据指定 1 个字符, 将原字符串填充够指定长度;l, 表示原字符串靠左   
        语法:ljust(width, fillchar)
        参数:width, 指定结果字符串长度; 
             fillchar, 如果原字符串长度 < 指定长度时, 填充过去的字符
        返回值:填充完毕的结果字符串
        注意:不会修改原字符串本身; 
             填充字符的长度为 1; 
             只有原字符串长度 < 指定结果长度时才会填充
        """
        nameStr = "coderqinzy"
        print(nameStr.ljust(16, "x"))
        print(nameStr)
        
      • rjust
        """
        功能使用, 同 ljust 一样
        区别:原字符串靠右
        """
        nameStr = "coderqinzy"
        print(nameStr.rjust(16, "x"))
        print(nameStr)
        
      • center
        """
        功能使用, 同 ljust 一样
        区别:原字符串居中
        """
        nameStr = "coderqinzys"
        print(nameStr.center(16, "x"))
        print(nameStr)
        
      • strip
        """
        作用:移除字符串头尾指定的字符(默认为空格)
        语法:strip(chars) 
        参数:需要移除的字符集, 表现形式为字符串; "abc", 表示"a"|"b"|"c"
        返回值:移除完毕的结果字符串
        注意:不会修改原字符串本身;
             只能删除开头和结尾的字符, 不能删除中间的字符
        """
        str = ' wxx '
        result_str = str.strip()
        print(result_str)
        
      • lstrip
        """
        作用:移除所有原字符串指定字符(默认为空白字符); l, 表示仅仅只移除左侧
        语法:lstrip(chars) 
        参数:需要移除的字符集, 表现形式为字符串; "abc", 表示"a"|"b"|"c"
        返回值:移除完毕的结果字符串
        注意:不会修改原字符串本身; 
             若从左侧开始 没有找到 相关字符,则不做任何操作
        """
        nameStr = " my name is coder qin zy "
        print("|" + nameStr.lstrip() + "|")
        print("|" + nameStr + "|")
        nameStr = "mmmmyy name is coder qin zy "
        print("|" + nameStr.lstrip("my") + "|")
        print("|" + nameStr + "|")
        nameStr = "my name is coder qin zy "
        print("|" + nameStr.lstrip("wo") + "|")
        print("|" + nameStr + "|")
        
      • rstrip
        """
        功能使用, 同 lstrip 一样
        区别:仅仅只移除右侧
        """
        nameStr = "my name is coder qin zy "
        print("|" + nameStr.rstrip() + "|")
        print("|" + nameStr + "|")
        nameStr = "my name is coder qin zyzyzy"
        print("|" + nameStr.rstrip("zy") + "|")
        print("|" + nameStr + "|")
        nameStr = "my name is coder qin zyzyzya "
        print("|" + nameStr.rstrip("zy") + "|")
        print("|" + nameStr + "|")
        
    • 分割拼接
      • split
        """
        作用:将一个大的字符串分割成几个子字符串
        语法:split(sep, maxsplit)
        参数:sep, 分隔符; 
             maxsplit, 最大的分割次数, 可省略, 有多少分割多少
        返回值:分割后的子字符串, 组成的列表, list 列表类型
        注意:不会修改原字符串本身
        """
        infoStr = "wx-18-180-0337-12345678"
        resultList = infoStr.split("-", 3)
        print(infoStr)
        print(resultList)
        
      • partition
        """
        作用:根据指定的分隔符, 返回(分隔符左侧内容, 分隔符, 分隔符右侧内容)
        语法:partition(sep)
        参数:sep, 分隔符
        返回值:如果查找到分隔符, (分隔符左侧内容, 分隔符, 分隔符右侧内容), tuple 类型; 
               如果没有查找到分隔符, (原字符串, "", ""), tuple 类型
        注意:不会修改原字符串本身; 
             从 左侧 开始查找分隔符
        """
        infoStr = "wx-18-180-0337-12345678"
        resultList = infoStr.partition("-")
        print(infoStr)
        print(resultList)
        
      • rpartition
        """ 
        功能使用, 同 partition 一样
        区别:从 右侧 开始查找分隔符
        """
        infoStr = "wx-18-180-0337-12345678"
        resultList = infoStr.rpartition("-")
        print(infoStr)
        print(resultList)
        
      • splitlines
        """
        作用:按照换行符(\r, \n), 将字符串拆成多个元素, 保存到列表中
        语法:splitlines(keepends)
        参数:keepends, 是否保留换行符, bool 类型
        返回值:被换行符分割的多个字符串, 作为元素组成的列表, list 类型
        注意:不会修改原字符串本身
        """
        nameStr = "my name \n is \r wang"
        resultList = nameStr.splitlines(True)
        print(resultList)
        print(nameStr)
        
      • join
        """
        作用:根据指定字符串, 将给定的可迭代对象, 进行拼接, 得到拼接后的字符串
        语法:join(iterable)
        参数:iterable, 可迭代对象, 字符串, 元组, 列表...
        返回值:拼接好的新字符串
        """
        items = ["qinzy", "18", "hangzhou"]
        resultStr = "xxx".join(items)
        print(resultStr)
        
    • 判定真假
      • isalpha
        """
        作用:字符串中是否所有的字符都是字母; 
             不包含数字, 特殊符号, 标点符号等等; 
             至少有一个字符
        语法:isalpha()
        参数:无
        返回值:是否全是字母, bool 类型
        """
        nameStr = "coderqinzy"
        print(nameStr.isalpha())
        
      • isdigit
        """
        作用:字符串中是否所有的字符都是数字; 
             不包含字母, 特殊符号, 标点符号等等; 
             至少有一个字符
        语法:isdigit()
        参数:无
        返回值:是否全是数字, bool 类型
        """
        nameStr = "20180410"
        print(nameStr.isdigit())
        
      • isalnum
        """
        作用:字符串中是否所有的字符都是数字或者字母; 
             不包含特殊符号, 标点符号等等; 
             至少有一个字符
        语法:isalnum()
        参数:无
        返回值:是否全是数字或者字母, bool 类型
        """
        nameStr = "qinzy66888"
        print(nameStr.isalnum())
        
      • isspace
        """
        作用:字符串中是否所有的字符都是空白符; 
             包括空格, 缩进, 换行等不可见转义符; 
             至少有一个字符
        语法:isspace()
        参数:无
        返回值:是否全是空白符, bool 类型
        """
        nameStr = "\n"
        print(nameStr.isspace())
        
      • startswith
        """
        作用:判定一个字符串是否以某个前缀开头
        语法:startswith(prefix, start=0, end=len(str))
        参数:prefix, 需要判定的前缀字符串; 
             start, 判定起始位置; 
             end, 判定结束位置
        返回值:是否以指定前缀开头, bool, 类型
        """
        dateStr = "2020-04-17: 述职报考.xls"
        print(dateStr.startswith("04", 5, 7))
        
      • endswith
        """
        作用:判定一个字符串是否以某个后缀结尾
        语法:endswith(suffix, start=0, end=len(str))
        参数:suffix, 需要判定的后缀字符串; 
             start, 判定起始位置; 
             end, 判定结束位置
        返回值:是否以指定后缀结尾, bool 类型
        """
        dateStr = "2020-04-17: 述职报考.xls"
        print(dateStr.endswith(".xls"))
        
      • in
        """
        语句:判定一个字符串, 是否被另外一个字符串包含
        """
        name = "coder qin"
        nameStr = "coder qin zy"
        print(name in nameStr)
        
      • not in
        """
        语句:判定一个字符串, 是否没有被另外一个字符串包含
        """
        name = "coder qin tt"
        nameStr = "coder qin zy"
        print(name not in nameStr)
        

你可能感兴趣的:(常用数据类型操作(二))