精华内容
下载资源
问答
  • 安利一句话:字符串是不可的对象,所以任何操作对原字符串是不改变的! 1.字符串切割 def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__ """ S.split(sep=...
        安利一句话:字符串是不可变的对象,所以任何操作对原字符串是不改变的!
    
    1.字符串的切割
        def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
            """
            S.split(sep=None, maxsplit=-1) -> list of strings
            
            Return a list of the words in S, using sep as the
            delimiter string.  If maxsplit is given, at most maxsplit
            splits are done. If sep is not specified or is None, any
            whitespace string is a separator and empty strings are
            removed from the result.
            """
            return []
    
            用法:返回字符串中所有单词的列表,使用 sep 作为分隔符(默认值是空字符(空格))用什么切就去掉什么。
                 可以使用 maxsplit 指定最大切分数。
            例子:     s = 'STriSSB'
                      print(s.split('STriSSB')) ----> ['', '']
                      print(s.split('S')) ----> ['', 'Tri', '', 'B']
            注意:如果切分的参数 sep 在字符串的左边或者右边,最后切得的链表中会存在一个空字符串。(如:['',等])
                 如果切分的参数 sep 是整个字符串,那么切分结果为两个空字符串组成的列表。(['',''])
    
        def rsplit(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
            """
            S.rsplit(sep=None, maxsplit=-1) -> list of strings
            
            Return a list of the words in S, using sep as the
            delimiter string, starting at the end of the string and
            working to the front.  If maxsplit is given, at most maxsplit
            splits are done. If sep is not specified, any whitespace string
            is a separator.
            """
            return []
    
            用法:返回字符串中所有单词的列表,使用 sep 作为分隔符(默认值是空字符(空格))
                 可以使用 maxsplit 指定最大切分数。只不过切的时候是从右边开始切。
            例子:    s = 'STriSSB'
                    print(s.split('STriSSB'))       ----------> ['', '']
                    print(s.rsplit('STriSSB'))      ----------> ['', '']
                    print(s.split('S'))             ----------> ['', 'Tri', '', 'B']
                    print(s.rsplit('S'))            ----------> ['', 'Tri', '', 'B']
                    print(s.split('S', maxsplit=1)) ----------> ['', 'TriSSB']
                    print(s.rsplit('S', maxsplit=1))----------> ['STriS', 'B']
    
    2.字符串连接
        def join(self, iterable): # real signature unknown; restored from __doc__
            """
            S.join(iterable) -> str
            
            Return a string which is the concatenation of the strings in the
            iterable.  The separator between elements is S.
            """
            return ""
    
            用法:用S连接序列iterable的所有元素并返回。序列iterable的元素必须全是字符串。
                 join()方法是split()方法的逆方法,用来把列表中的个字符串联起来。
    
    3.字符串的查找
        def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
            """
            S.find(sub[, start[, end]]) -> int
            
            Return the lowest index in S where substring sub is found,
            such that sub is contained within S[start:end].  Optional
            arguments start and end are interpreted as in slice notation.
            
            Return -1 on failure.
            """
            return 0
    
        用法:返回字符串sub的第一个索引,如果不存在这样的索引则返回-1,可定义搜索的范文为S[start:end].
    
        def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
            """
            S.index(sub[, start[, end]]) -> int
            
            Return the lowest index in S where substring sub is found, 
            such that sub is contained within S[start:end].  Optional
            arguments start and end are interpreted as in slice notation.
            
            Raises ValueError when the substring is not found.
            """
            return 0
    
            用法:返回字符串sub的第一个索引,或者在找不到索引的时候引发 ValueError异常,可定义索引的范围为S[start:end].
    
        def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
            """
            S.startswith(prefix[, start[, end]]) -> bool
            
            Return True if S starts with the specified prefix, False otherwise.
            With optional start, test S beginning at that position.
            With optional end, stop comparing S at that position.
            prefix can also be a tuple of strings to try.
            """
            return False
    
            用法:检测S是否是以prefix开始,可定义搜索范围为S[start:end].
    
        def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
            """
            S.endswith(suffix[, start[, end]]) -> bool
            
            Return True if S ends with the specified suffix, False otherwise.
            With optional start, test S beginning at that position.
            With optional end, stop comparing S at that position.
            suffix can also be a tuple of strings to try.
            """
            return False
    
            用法:检测S是否以suffix结尾,可定义搜索范围为S[start:end]
    
    
    4.字符串的替换
        def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
            """
            S.replace(old, new[, count]) -> str
            
            Return a copy of S with all occurrences of substring
            old replaced by new.  If the optional argument count is
            given, only the first count occurrences are replaced.
            """
            return ""
    
            用法:返回字符串的副本,其中old的匹配项都被替换为new,可选择最多替换count个(从左往右替换),默认替换全部。
    
    
    5.字符串的删除
        def strip(self, chars=None): # real signature unknown; restored from __doc__
            """
            S.strip([chars]) -> str
            
            Return a copy of the string S with leading and trailing
            whitespace removed.
            If chars is given and not None, remove characters in chars instead.
            """
            return ""
    
            用法:返回字符串的副本,其中所有的chars(默认为空格)都被从字符串的开头和结尾删除(默认为所有的空白字符,如空格,tab和换行符。)
    
        def lstrip(self, chars=None): # real signature unknown; restored from __doc__
            """
            S.lstrip([chars]) -> str
            
            Return a copy of the string S with leading whitespace removed.
            If chars is given and not None, remove characters in chars instead.
            """
            return ""
    
            用法:返回一个字符串副本,其中所有的char(默认为所有的空白字符,如空格,tab和换行符。)都被从字符串左端删除。
    
        def rstrip(self, chars=None): # real signature unknown; restored from __doc__
            """
            S.rstrip([chars]) -> str
            
            Return a copy of the string S with trailing whitespace removed.
            If chars is given and not None, remove characters in chars instead.
            """
            return ""
            
            用法:返回一个字符串副本,其中所有的char(默认为所有的空白字符,如空格,tab和换行符。)都被从字符串右端删除。
    
    
    6.统计字符串出现次数
        def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
            """
            S.count(sub[, start[, end]]) -> int
            
            Return the number of non-overlapping occurrences of substring sub in
            string S[start:end].  Optional arguments start and end are
            interpreted as in slice notation.
            """
            return 0
    
            用法:计算字符串sub的出现次数,可以定义搜索的范围为S[start:end]
    
    
    7.字符串字母大小写转换
        def upper(self): # real signature unknown; restored from __doc__
            """
            S.upper() -> str
            
            Return a copy of S converted to uppercase.
            """
            return ""
    
            用法:返回字符串的副本,其中所有小写字母都转换为大写字母。
    
    
        def lower(self): # real signature unknown; restored from __doc__
            """
            S.lower() -> str
            
            Return a copy of the string S converted to lowercase.
            """
            return ""
    
            用法:返回字符串的副本,其中所有大写字母都转换为小写字母。
    
        def swapcase(self): # real signature unknown; restored from __doc__
            """
            S.swapcase() -> str
            
            Return a copy of S with uppercase characters converted to lowercase
            and vice versa.
            """
            return ""
    
            用法:返回字符串副本,其中大小写进行了互换。
    
        def title(self): # real signature unknown; restored from __doc__
            """
            S.title() -> str
            
            Return a titlecased version of S, i.e. words start with title case
            characters, all remaining cased characters have lower case.
            """
            return ""
    
            用发:返回字符串副本,其中单词都已大写字母开头。
    
    
    8.字符串条件判断
        def isalnum(self): # real signature unknown; restored from __doc__
            """
            S.isalnum() -> bool
            
            Return True if all characters in S are alphanumeric
            and there is at least one character in S, False otherwise.
            """
            return False
    
        def isalpha(self): # real signature unknown; restored from __doc__
            """
            S.isalpha() -> bool
            
            Return True if all characters in S are alphabetic
            and there is at least one character in S, False otherwise.
            """
            return False
    
        def isdecimal(self): # real signature unknown; restored from __doc__
            """
            S.isdecimal() -> bool
            
            Return True if there are only decimal characters in S,
            False otherwise.
            """
            return False
    
        def isdigit(self): # real signature unknown; restored from __doc__
            """
            S.isdigit() -> bool
            
            Return True if all characters in S are digits
            and there is at least one character in S, False otherwise.
            """
            return False
    
        def isidentifier(self): # real signature unknown; restored from __doc__
            """
            S.isidentifier() -> bool
            
            Return True if S is a valid identifier according
            to the language definition.
            
            Use keyword.iskeyword() to test for reserved identifiers
            such as "def" and "class".
            """
            return False
    
        def islower(self): # real signature unknown; restored from __doc__
            """
            S.islower() -> bool
            
            Return True if all cased characters in S are lowercase and there is
            at least one cased character in S, False otherwise.
            """
            return False
    
        def isnumeric(self): # real signature unknown; restored from __doc__
            """
            S.isnumeric() -> bool
            
            Return True if there are only numeric characters in S,
            False otherwise.
            """
            return False
    
        def isprintable(self): # real signature unknown; restored from __doc__
            """
            S.isprintable() -> bool
            
            Return True if all characters in S are considered
            printable in repr() or S is empty, False otherwise.
            """
            return False
    
        def isspace(self): # real signature unknown; restored from __doc__
            """
            S.isspace() -> bool
            
            Return True if all characters in S are whitespace
            and there is at least one character in S, False otherwise.
            """
            return False
    
        def istitle(self): # real signature unknown; restored from __doc__
            """
            S.istitle() -> bool
            
            Return True if S is a titlecased string and there is at least one
            character in S, i.e. upper- and titlecase characters may only
            follow uncased characters and lowercase characters only cased ones.
            Return False otherwise.
            """
            return False
    
        def isupper(self): # real signature unknown; restored from __doc__
            """
            S.isupper() -> bool
            
            Return True if all cased characters in S are uppercase and there is
            at least one cased character in S, False otherwise.
            """
            return False
            
     

     

    转载于:https://www.cnblogs.com/xiao-xue-di/p/9264071.html

    展开全文
  • Python-字符串学习笔记(完)

    千次阅读 多人点赞 2020-06-04 20:07:41
    文章目录字符串基本特点编码表示方式(创建)转义字符字符串拼接字符...Python字符串是不可的。 Python不支持单字符类型,单字符也是作为一个字符串使用的。 编码 Python3直接支持Unicode,可以表示世界上任何书面

    字符串

    基本特点

    字符串的本质是:字符序列。Python的字符串是不可变的。

    Python不支持单字符类型,单字符也是作为一个字符串使用的。

    编码

    • Python3直接支持Unicode,可以表示世界上任何书面语言的字符。Python3的字符默认就是16位Unicode编码,ASCII码是Unicode编码的子集。
    • 使用内置函数ord()获取字符对应的编码。
    • 使用内置函数chr()根据编码获取对应的字符。
    >>> ord('马')
    39532
    >>> chr(39532)
    '马'
    

    表示方式(创建)

    a = "I'm Tom"  # 一对双引号
    
    b = 'Tom said:"I am Tom"'  # 一对单引号
    
    c = '''Tom said:"I'm Tom"'''  # 一对三个单引号
    
    d = """Tom said:"I'm Tom" """  # 一对三个双引号
    

    转义字符

    使用 \来表示一个转义字符,\在行尾时,表示续行符。

    • \n 表示一个换行
    • \t 表示一个tab
    • \' 显示一个普通的单引号
    • \" 显示一个普通的双引号
    • \\ 表示一个普通的反斜线
    • \r 表示一个回车
    • \b 表示一个退格(backspace)

    注:在python中,在字符串的前面添加r,表示原生字符串

    k = r'good mor\ning'
    print(k)  # good mor\ning
    

    字符串拼接

    • str + str
    • 空格

    注:这两种方式都会生成新的字符串对象

    >>> 'a' + 'b'
    'ab'
    >>> 'c' 'd'
    'cd'
    

    字符串复制

    • str * int
    >>> 'jack'*3
    'jackjackjack'
    

    常见操作

    1. 获取长度
    • len函数可以获取字符串的长度

      mystr = '今天天气好晴朗,处处好风光呀好风光'
      print(len(mystr))  # 17 获取字符串的长度
      
    2. 查找内容
    • find

      • 返回所查找的内容在字符串中第一次出现的开始位置索引值,如果不存在,返回-1
      • S.find(sub[, start[, end]]) -> int
    • rfind

      • 类似于 find()函数,不过是从右边开始查找

        str1 = 'hello'
        print(str1.rfind('l'))  # 3
        
    • index

      • 与find()方法一样,只不过,find方法未找到时,返回 -1 ,而index未找到时,会报一个异常
    • rindex

      • 类似于 index(),不过是从右边开始
    3. 判断
    • startswith

      • 判断字符串是否以指定内容开始

      • S.startswith(prefix[, start[, end]]) -> bool

        print('hello'.startswith('he'))  # True
        
    • endswith

      • 判断字符串是否以指定内容结束

      • S.endswith(suffix[, start[, end]]) -> bool

        print('hello'.endswith('o'))  # True
        
    • isalpha

      • 判断字符串是否是纯字母

        mystr = 'hello world'
        print(mystr.isalpha()) # False 因为中间有空格
        
    • isdigit

      • 判断一个字符串是否是纯数字,只要出现非0~9的数字,结果就是False

        print('good'.isdigit())  # False
        
        print('123'.isdigit())  # True
        
        print('3.14'.isdigit())  # False
        
    • isalnum

      • 判断是否由数字和字母组成。只要出现了非数字和字母,就返回False

        print('hello123'.isalnum())  # True
        print('hello'.isalnum())  # True
        
    • isspace

      • 如果字符串中只包含空格,则返回 True,否则返回 False

        print('  '.isspace())  # True
        
    • isascii

      • 如果字符串中的所有字符都是ASCII,则返回True;否则返回False。

      • 判断时必须是字符串形式,否则会报错

        a = 'a'
        print(a.isascii())  # True
        
    • isupper

      • 字符串中所有的字母都为大写,则返回True;否则返回False

        b = 'Hello'
        print(b.isupper())  # False
        c = 'LUCY'
        print(c.isupper())  # True
        
    • islower

      • 字符串中所有的字母都为小写,则返回True;否则返回False

        b = 'Hello'
        print(b.islower())  # False
        c = 'lucy'
        print(c.islower())  # True
        
    • isnumeric

      • 检测字符串是否只由数字组成。这种方法是只针对unicode对象

        • 这里的数字包括:阿拉伯数字、罗马数字、中文简体数字、中文繁体数字
      • 定义一个字符串为Unicode,只需要在字符串前添加 ‘u’ 前缀即可

        str1 = u"一壹①②③⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮⑯ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩ❶❷❸❺❺❻❼❽❾❿2009"
        print(str1.isnumeric())  # True
        
    • isprintable

      • 判断是否为可打印字符串,如果所有字符都是可打印的,则返回 True,否则返回 False

      • 不可打印的字符可以是回车、换行符、制表符

        str1 = 'abc'
        print(str1.isprintable())  # True
        
        str2 = 'abc\tdef'
        print(str2.isprintable())  # False
        
    • istitle

      • 判断是否首字母大写,其他字母小写

        str1 = 'LuCy'
        print(str1.istitle())  # False
        str2 = 'Lucy Ha'
        print(str2.istitle())  # True
        
    • isidentifier

      • 判断字符串是否是有效的 Python 标识符

        str1 = 'True'
        print(str1.isidentifier())  # True 关键字作为变量名检测不出来
        str2 = '3abc'
        print(str2.isidentifier())  # False
        str3 = 'username'
        print(str3.isidentifier())  # True
        
      • 如果字符串仅包含字母数字或下划线,则该字符串被视为有效标识符。有效的标识符不能以数字开头或包含任何空格

    • isdecimal

      • 如果字符串是否只包含十进制字符返回True,否则返回False

        str1 = u"this2009"
        print(str1.isdecimal())  # False
        str2 = u"23443434"
        print(str2.isdecimal())  # True
        
      • 这种方法只存在于unicode对象

    4. 计算出现次数
    • count

      • 返回 所查询字符串 在start和end之间 在 原字符串 里面出现的次数

      • S.count(sub[, start[, end]]) -> int

        str1 = 'hello'
        print(str1.count('l'))  # 2
        
    5. 替换内容
    • replace

      • 替换字符串中指定的内容,如果指定次数count,则替换不会超过count次

      • replace(self, old, new, count)

        msg = '他很牛逼,他很秀,他很帅'
        msg1 = msg.replace('他', 'lucy')  # 默认全部替换
        msg2 = msg.replace('他', 'lucy', 2)  # 从左至右,替换前两个
        print(msg1)  # lucy很牛逼,lucy很秀,lucy很帅
        print(msg2)  # lucy很牛逼,lucy很秀,他很帅
        
        • 所要替换的字符不在字符串中也不会报错

          s1 = 'abcd'
          print(s1.replace('lucy', 'cc'))  # abcd
          
      • 整个过程中,实际上是创建了新的字符串,原字符串并没有改变。

    6. 切割字符串
    • split

      • 可以将一个字符串切割成一个列表

      • 默认最大分割数为-1,表示无限制,可以省略;也可以自己指定最大分割数

        x = 'zhangsan-hahaha-tom-tony-lucy'
        y = x.split('-', -1)
        z = x.rsplit('-')
        print(y)  # ['zhangsan', 'hahaha', 'tom', 'tony', 'lucy']
        print(z)  # ['zhangsan', 'hahaha', 'tom', 'tony', 'lucy']
        
        x = 'zhangsan-hahaha-tom-tony-lucy'
        print(x.split('-', 2))  # ['zhangsan', 'hahaha', 'tom-tony-lucy']
        
        x = '-hahaha-tom-tony-lucy'
        y = x.split('-')
        
        print(y)  # ['', 'hahaha', 'tom', 'tony', 'lucy']
        
      • 默认按照空格、换行符、制表符分割

        s = 'my name is lucy'
        s1 = s.split()
        print(s1)  # ['my', 'name', 'is', 'lucy']
        
    • rsplit

      • 用法和split基本一致,只不过是从右往左分割

        x = 'zhangsan-hahaha-tom-tony-lucy'
        print(x.rsplit('-', 2))  # ['zhangsan-hahaha-tom', 'tony', 'lucy']
        
    • splitlines

      • 按照行分隔,返回一个包含各行作为元素的列表

        str1 = 'hello\nworld'
        print(str1.splitlines())  # ['hello', 'world']
        
    • partition

      • 指定一个字符串str作为分隔符,将原字符串分为三部分,str前,str,str后。这三部分组成一个元组

        print('agdaXhhXhjjs'.partition('X'))  # ('agda', 'X', 'hhXhjjs')
        
    • rpartition

      • 类似于partition()函数,不过是从右边开始

        print('agdaXhhXhjjs'.rpartition('X'))  # ('agdaXhh', 'X', 'hjjs')
        
    7. 修改大小写
    • capitalize

      • 第一个单词的首字母大写

        mystr = 'hello world'
        print(mystr.capitalize()) # Hello world
        
    • title

      • 每个单词的首字母大写

        mystr = 'hello world'
        print(mystr.title()) # Hello World
        
    • lower

      • 所有都变成小写

        mystr = 'hElLo WorLD'
        print(mystr.lower()) # hello world
        
    • upper

      • 所有都变成大写

        mystr = 'hello world'
        print(mystr.upper())  #HELLO WORLD
        
    • casefold()

      • 将字符串中的所有大写字母转换为小写字符

        s1 = 'I Love Python'
        print(s1.casefold())  # i love python
        
    • swapcase()

      • 将字符串中小写转为大写,大写转为小写

        s1 = 'I Love Python'
        print(s1.swapcase())  # i lOVE pYTHON
        
    8. 空格处理
    • ljust

      • 返回指定长度的字符串,并在右侧使用空白字符补全(左对齐)

        str = 'hello'
        print(str.ljust(10))  # hello     在右边补了五个空格
        
      • 如果本身长度大于指定长度,则不做任何处理

      • 可以指定填充字符,默认是空格

        print('lucy'.ljust(10, '+'))  # lucy++++++
        
    • rjust

      • 返回指定长度的字符串,并在左侧使用空白字符补全(右对齐)

        str = 'hello'
        print(str.rjust(10))  #      hello在左边补了五个空格
        
      • 可以指定填充字符,默认是空格

    • center

      • 返回指定长度的字符串,并在两端使用空白字符补全(居中对齐)

        str = 'hello'
        print(str.center(10))  #  hello   两端加空格,让内容居中
        
      • 可以指定填充字符,默认是空格

    • 去除前后空白,空白有:空格、\t(制表符)、\n(换行符)

      • lstrip

        • 删除字符串左边的空白字符

          mystr = '    he   llo      '
          print(str.lstrip())  #he   llo      只去掉了左边的空格,中间和右边的空格被保留
          
      • rstrip

        • 删除字符串右边的空白字符

          mystr = '    he   llo      '
          print(str.rstrip())  #    he   llo右边的空格被删除
          
      • strip

        • 删除字符串两边的空白字符

          str = '    he   llo      '
          print(str.strip())  #he   llo
          
        • 指定删除字符

          s = 'fgk太k白ser'
          s1 = s.strip('fkgres')  # 前后同时进行
          print(s1)  # 太k白
          
    • expandtabs()

      • 把字符串中的 tab 符号(’\t’)转为空格,tab 符号(’\t’)默认的空格数是 8

        s1 = 'a\tbcd'
        print(s1)
        print(s1.expandtabs())
        print(s1.expandtabs(tabsize=4))
        print(s1.expandtabs(tabsize=0))
        # a	bcd
        # a       bcd
        # a   bcd
        # abcd
        
    9. 字符串拼接
    • join

      • S.join(iterable)

        s = 'lucy'
        s1 = '+'.join(s)
        print(s1)  # l+u+c+y
        
        print('+'.join({'name': 'lucy', 'age': 18}))  # name+age
        
      • 作用:可以把列表或者元组快速的转变成为字符串,并且以指定的字符分隔

        • 前提:列表或者元组里面的元素必须都是 str 类型

          l1 = ['my', 'name', 'is', 'lucy']
          s1 = ' '.join(l1)
          print(s1)  # my name is lucy
          
      • 建议使用这种方式进行字符串拼接,效率比 str+str 高,因为 join 只创建一次字符串对象。

    10. 加密解密(映射替换)
    • maketrans

      创建字符映射的转换表。

      str.maketrans(intab, outtab,delchars)

      intab -- 字符串中要替代的字符组成的字符串。
      outtab -- 相应的映射字符的字符串。
      delchars -- 可选参数,表示字符串中的每个字符都会被映射为None
      
      intab和outtab都是字符串,且长度必须相等
      
    • translate

      根据maketrans()函数给出的转换表来转换字符串中的字符。

      注:先过滤(转为None),然后转换

    in_str = 'afcxyo'
    out_str = '123456'
    
    # maketrans()生成转换表,必须使用str调用
    # map_table的类型是字典
    map_table = str.maketrans(in_str, out_str)
    
    # 使用translate()进行转换
    my_love = 'I love fairy'
    new_my_love = my_love.translate(map_table)
    
    print(new_my_love)  # I l6ve 21ir5
    
    in_str = 'afcxyo'
    out_str = '123456'
    
    # maketrans()生成转换表,必须使用str调用
    map_table = str.maketrans(in_str, out_str, 'yo')
    
    # 使用translate()进行转换
    my_love = 'I love fairy'
    new_my_love = my_love.translate(map_table)
    
    print(new_my_love)  # I lve 21ir
    
    11. 字符串前补0
    • zfill()

      • 返回指定长度的字符串,原字符串右对齐,前面填充 0
      a = 3
      b = str(a).zfill(4)
      print(b)  # 0003
      
      • 使用场景

      字符串格式的数字在排序时跟我们预想的不太一样,比如11排在2前面,这样就带来了一些问题,比如合并一些用数字命名的文件时,合并文件的顺序可能就发生变化了,那么在数字前面填充0,让这些数字的长度保持一致,问题就解决了。

    切片(slice)

    切片:就是从字符串里复制一段指定的内容,生成一个新的字符串

    m[start:end:step] 顾头不顾尾

    • step:步长。默认为1

      m = 'abcdefghigklmnopqrstuvwxyz'
      print(m[2:9])  # cdefghi
      

      步长不能为0,否则报错

      m = 'abcdefghigklmnopqrstuvwxyz'
      print(m[2:9:0])  # 报错
      
    • 步长为负数时,表示从右往左获取

      m = 'abcdefghigklmnopqrstuvwxyz'
      print(m[3:15:-1])  # 没有数据
      print(m[15:3:-1])  # ponmlkgihgfe
      
    • start和end如果是负数时,表示索引从右边数

      m = 'abcdefghigklmnopqrstuvwxyz'
      print(m[-9:-5])  # rstu
      
    • 倒序

      m = 'abcdefghigklmnopqrstuvwxyz'
      print(m[::-1])  # zyxwvutsrqponmlkgihgfedcba
      
    • 如果只设置了start,会“截取”到最后

      m = 'abcdefghigklmnopqrstuvwxyz'
      print(m[2:])  # cdefghigklmnopqrstuvwxyz
      
    • 如果只设置了end,会从头开始“截取”

      m = 'abcdefghigklmnopqrstuvwxyz'print(m[:9])  # abcdefghi
      
    • 如果 start 、end 不在 [0, 字符串长度 - 1] 这个范围内,也不会报错

      m = 'abcdefghigklmnopqrstuvwxyz'
      print(m[-100:-1])  # abcdefghigklmnopqrstuvwxy
      

    字符串驻留机制

    字符串驻留:仅保存一份相同且不可变字符串的方法,不同的值被存放在字符串驻留池中。

    Python支持字符串驻留机制,对于符合标识符规则的字符串(仅包含下划线(_)、字母和数字)会启用字符串驻留机制驻留机制。

    >>> a = 'abc_123'
    >>> b = 'abc_123'
    >>> a is b
    True
    >>> c = 'abc#'
    >>> d = 'abc#'
    >>> c is d
    False
    

    可变字符串

    在Python中,字符串属于不可变对象,不支持原地修改,如果需要修改其中的值,只能创建新的字符串对象。但是,经常我们确实需要原地修改字符串,可以使用io.StringIO对象array模块,不会创建新的字符串。

    >>> import io
    >>> s = 'hello, Lucy'
    >>> sio = io.StringIO(s)
    >>> sio
    <_io.StringIO object at 0x7f8bbfdd8948>
    >>> sio.seek(4)
    4
    >>> sio.write('k')
    1
    >>> sio.getvalue()
    'hellk, Lucy'
    
    展开全文
  • 使用单引号、双引号、三引号引住的字符序列4.python3中、字符串就是unicode类型、在2中分两种一种unicode一种非unicode字符串元素访问--下标:1.字符串支持使用索引访问2.有序的字符集合,字符序列3.是可迭代的字符串...

    字符串:
    1.是由一个个字符组成有序的序列,是字符的集合
    2.字符串是不可变对象
    3.使用单引号、双引号、三引号引住的字符序列
    4.python3中、字符串就是unicode类型、在2中分两种一种unicode
    一种非unicode
    字符串元素访问--下标:
    1.字符串支持使用索引访问
    2.有序的字符集合,字符序列
    3.是可迭代的
    字符串join连接:
    1.字符串可以拼接起来、如
    (重复拼接)、+(两个拼接成一个新的)
    2.将可迭代对象连接起来、string作为分隔符
    3.可迭代对象本身元素应是字符串
    4.返回一个新字符串
    5.string.join(iterable) -> str
    示例:.a = list(range(5))
    ','.join(a)#将list:a用逗号作为分隔符,用join将其拼接起来
    因a为int非str会报TypeError

    print(','.join(map(str,range(5))))#所以,应将可迭代对象range(5)转换成str在用join来拼接
    字符串分割:
    split:
    1.从左至右
    2.sep指定分割字符串,缺省的情况下空白字符串作为分隔符
    3.maxsplit指定分割的次数,-1表示遍历整个字符串
    4.返回为list
    5.split(sep = None,maxsplit=-1)->list of strings
    rsplit:
    1.从左至右
    2.sep、maxsplit与split定义相同
    3.rsplit(sep=None,maxsplit=-1)- > list of strings
    splitlines:
    1.从左至右
    2.keepends,指定的是,是否保留行分隔符
    3.行分隔符包括\n、\r\n、\r等
    4.splitlines([keepends])- >list of string
    partition:
    1.从左至右、遇到分隔符就把字符串分割成两部分、返回头、分隔符、尾三部分的三元组;如果没有找到分隔符,就返回头、2个空元素的三元组
    2.sep分割字符串,必须指定
    3.partition(sep) - > (head.sep.tail)
    rpartition:
    1.从右制左,遇到分隔符就把字符串分割成两部分,返回头,分隔符,尾三部分的三元组;如果没有找到分隔符,就返回2个空元素和尾部的三元组
    字符串大小写:
    upper()
    全大写
    lower()
    全小写
    swapcase
    大小写,做判断的时候用
    交互大小写
    字符串排版:
    1.title() - >str
    标题的每个单词都大小写
    2.capitalize() - > str
    首个单词大写
    3.center(width[,fillchar]) ->str
    width打印宽度
    fillchar填充的字符
    4.zfill(width)->str
    width 打印宽度,居中,左边用0填充
    5.ljust(width[,fillchar]) ->str 左对齐
    6.rjust(width[,fillchar]) ->str 右对齐

    转载于:https://blog.51cto.com/13531464/2158261

    展开全文
  • 1.字符串是不可数据类型,你可以这样去理解:例如我们想要得到按"_",切割后的字符串b=“我很帅” eg:a="我_很_帅" b=(str)a.split("_") #不可以是a.split("_"),不创建一个新的变量来接收切割后的a 此例中,我们开辟...

    1.字符串是不可变数据类型,你可以这样去理解:例如我们想要得到按"_",切割后的字符串b=“我很帅”

    eg:a="我_很_帅"
    b=(str)a.split("_") #不可以是a.split("_"),不创建一个新的变量来接收切割后的a
    

    此例中,我们开辟了一个存储空间,用来存放字符串a,因为字符串是不可变的数据类型,因此当你想要得到进行切割,添加等操作后的字符串时,你需要重新开辟一个存储空间来存放操作后的新字符串.而a不管你做什么操作,它依然不会有任何变化,依然是"我_很_帅"

    eg:a="我_很_帅"
    b=(str)a.split("_")
    print("a="+a)
    结果:a=我很帅
    

    2.剩下的就是小数据池,我会在下章进行介绍

    展开全文
  • 1. 字符串字符串是不可的) 1.1 单引号、双引号、三引号 单引号与双引号无区别,两者可以互相做转义, 三引号可以多行打印,单三引号与双三引号也无区别。 1.2 运算 + * [] [:] in not in len() 1.3 r b u ...
  • Recipe 1.7. Reversing a String by Words or CharactersRecipe 1.7....解法字符串是不可(immutable)对象,因此若要进行反序排列操作,我们就需要生成新字符串。最简单的反序办法是以 -1 为步进单位进行切割操作
  • python 切片操作

    2021-03-30 19:46:07
    1. 对切片的理解:花样切割字符串切割对象——容器。 2. 语法规则: object[start_index:end_index:step] 对象[开始位置索引:结束位置索引:步长] 3. 注意事项: python是弱语言,切片操作时,索引位置和步长可正可负、...
  • Python字典

    2019-06-08 08:49:47
    序列是以连续的整数为索引,字典以关键字为索引,关键字可以是任意不可类型,通常用字符串或数值。 如果元组中只包含字符串和数字,它可以做为关键字,如果它直接或间接的包含了可对象,就不能当做关键字。不能...
  • 尹成Python27天入门到项目实战

    千人学习 2020-12-05 17:04:22
    python字符串与绘图复习变量None变量参与运算没有赋值的情况不会改变绘制立方体绘制五角星时间计算强化实现贷款计算连续输入多个字符串加法与绘图实现显示线段长度数据函数使用快速查阅函数帮助字符串三种风格字符...
  • python)字典

    2018-06-06 21:38:42
    关键字可以是任意不可类型,通常用字符串或数值。如果元组中只包含字符串或数字,它也可以做为字典的关键字,但是它如果直接或间接的包含了可对象,就不能当做关键字。不能用列表做关键字,因为列表可以用索引、...
  • python 获取 url 域名

    2020-01-19 14:55:26
    1.切割 url 字符串,把域名单独拿出来 2.正则匹配 3.借用别人写好的包 个人推荐第三种哈,要不然冷落了别人不好,毕竟大家都是同行 举例 py2.7环境,py3 可能用法有 import urlparse host = urlparse.urlparse('...
  • python中的增删改查

    2021-04-27 20:41:30
    字符串 str (不可 有序) 1.查找 find() 存在 索引 不存在 -1 2.修改 replace() 替换 字符串序列.replace(旧,新,次数) 次数不填默认-1 split() 切割 以…分割 返回列表 分隔符丢失 join() 组合 ‘…’.join() ...
  • 列表中的元素可以是Python中的任何对象,可以是字符串、整数、元组、也可以是list等 列表中值的切割可以用到变量[头下标:尾下标],从左到右索引默认 0 开始,从右到左索引默认 -1 开始,下标可以为空表示取...
  • python05元组字典

    2019-10-13 16:17:50
    1、元组操作 #将列表转成元组 优势 元组不可 ...#截取 .split(str= "*",num) 截取字符串遇到*号截取,num四几次 str1 = "wan****quan*zui****shuai" str2 = str1.split("*",8) print(str2) #按行切割 split...
  • 如果元组中只包含字符串和数字,它可以做为关键字,如果它直接或间接的包含了可对象,就不能当做关键字。不能用链表做关键字,因为链表可以用索引、切割或者 append()和 extend() 等方法改变。 字典的 keys()...
  • 元组与集合

    千次阅读 2019-06-07 21:29:46
    列表和字符串有很多通用的属性,例如索引和切割操作。它们是 序列 类型中的两种。因为 Python 是一个在不停进化的语言,也可能会加入其它的序列类型,这 里介绍另一种标准序列类型: 元组 。 一个元组由数个逗号分隔...
  • Python字符串相似性算法库、PyLaia:面向手写文档分析的深度学习工具包、TextFooler:针对文本分类/推理的对抗文本生成模块、Haystack:灵活、强大的可扩展问答(QA)框架、中文关键短语抽取工具。 1. textfilter: ...

空空如也

空空如也

1 2
收藏数 21
精华内容 8
关键字:

python字符串变切割

python 订阅